# Apify Alternativa a YouTube Dati

Confronta FlashData con Apify YouTube attori: prezzi specifici per attore, budget di utilizzo mensili, flussi di lavoro di metadati e didascalie ed esempi di migrazione eseguibili Python e Bash.

Dall'attore corre alle ricerche video dirette. Inizia con IDs noti, preserva i campi di applicazione e sposta un produttore prima di modificare il resto della pipeline.

I fatti Apify hanno recensito 2026-11-10. Le aliquote e gli assegni di prova FlashData utilizzano i suoi attuali cataloghi pubblici.

- [Caratteristiche](#features)
- [Prezzi degli attori](#actors)
- [Confronta i costi](#costs)
- [Migrare una ricerca](#migration)
- [Set di dati e pianificazioni](#production)
- [Per gli agenti IA](#agents)
- [Domande frequenti](#faq)

<a id="features"></a>
## Confronto delle funzionalità

### Mantieni le ricerche mirate economiche

| Caratteristica | FlashData | Apify YouTube attori |
| --- | --- | --- |
| Utilizzo a pagamento senza abbonamento mensile | Sì — Crediti a consumo; ricariche da $10 | Budget gratuito, quindi un piano a pagamento — $5/mese gratuito; Starter $19/mese con utilizzo $19 |
| Metadati per 1,000 video conosciuti IDs | $0.50 — Tariffa di utilizzo a consumo | $3.00 — streamers/youtube-scraper · Tasso Starter, detratto dal budget del piano |
| Ricerca di un video | Sì — Un video_id esplicito | Dipendente dall'attore — Gli streamer lo supportano; API Dojo attualmente esclude il video singolo URLs |

### Trova e arricchisci i video di cui la tua app ha bisogno

| Caratteristica | FlashData | Apify YouTube attori |
| --- | --- | --- |
| Individuazione delle parole chiave con filtri di ricerca | Sì — Data, durata, tipologia e filtri di ordinamento | Sì — searchQueries più filtri di ordinamento, data e video |
| Dati su titolo, canale e coinvolgimento | Sì — Ricerca metadati dedicata tramite video ID | Sì — Registrazioni video nel set di dati Actor |
| Aggiorna i metadati separatamente dalle didascalie | Sì — Richiedi solo youtube_metadata per l'aggiornamento | Sì — Esegui con transcriptionAndSubtitle=NESSUNO |

### Prepara le prove delle didascalie per la tua applicazione

| Caratteristica | FlashData | Apify YouTube attori |
| --- | --- | --- |
| Scegli diverse lingue dei sottotitoli esistenti | Fino a 10 lingue esplicite — Tiene traccia degli errori per lingua in un'unica richiesta di trascrizione | Attore principale: una lingua o qualsiasi altra — Attori diversi possono esporre input diversi |
| Seleziona un'origine didascalia rigorosa | Uploader o YouTube generato — params.auto seleziona un'origine; nessun fallback multiorigine | Attore principale: preferenza di origine — preferAutoGeneratedSubtitles è una preferenza, non lo stesso contratto |
| Testo con timestamp per le citazioni delle fonti | Segmenti JSON normalizzati — Testo con inizio/end volte in secondi | Sottotitoli SRT, VTT o XML — Analizza il formato dei sottotitoli selezionato per i tempi delle citazioni |
| Testo semplice per il riepilogo | fullText accanto ai segmenti | formato dei sottotitoli in testo normale — Oppure analizza e unisci l'output dei sottotitoli temporizzati |
| Video senza una trascrizione esistente | Segnala la traccia mancante — Nessuna generazione da parlato a testo | Trascrizione AI opzionale — Modalità fallback o trascrizione sempre; spese di utilizzo separate |

### Esegui il flusso di lavoro con meno codice di integrazione

| Caratteristica | FlashData | Apify YouTube attori |
| --- | --- | --- |
| Risultato diretto senza gestire le risorse dell'attore | Risultati in tempo reale[] + utilizzo — Nessun attore ID, build o impostazione di memoria | Esecuzione dell'attore + schema di input — L'endpoint di sincronizzazione può anche restituire risultati in una chiamata HTTP |
| Elabora un elenco salvato in una console del browser | Bulk Jobs con un file video-ID — Tieni traccia dei progressi e recupera le parti manifest e dei risultati | Console attore con URL ingressi — Supporta importazioni di fogli CSV o Google |
| Risultati in background dopo la disconnessione del client | Salvato async o Lavoro in blocco ID — Riprendi i controlli di stato e recupera completed output | Esecuzione attore e set di dati salvati IDs — Ispezionare la corsa e recuperare gli elementi del set di dati |
| Formati di output dell'applicazione e dell'agente | JSON, testo semplice o Markdown | Esportazioni di set di dati — JSON, CSV, Excel e altri formati |
| Collezione ricorrente | Il tuo pianificatore o host agente — Riutilizza le credenziali del proprietario e lo stato del lavoro salvato | Orari degli attori ospitati — Cron, impostazioni del fuso orario e webhook opzionali |
| Metadati, didascalie e ricerca Google in un contratto API | Una query API, autorizzazioni specifiche dell'origine — Saldo del conto condiviso; prezzi specifici della fonte | Piattaforma condivisa; Schemi specifici dell'attore — Scegliere e mantenere gli input e gli output degli attori rilevanti |
| CLI, SDK e MCP per l'automazione | Sì — Autonomo CLI; SDK Python, TypeScript e Go; MCP | Sì — Apify CLI, Python/JavaScript clienti e MCP |

Le righe specifiche dell'attore si riferiscono agli streamer/youtube-scraper a meno che non venga nominato un altro attore. Entrambi i servizi offrono SDK, CLI e MCP. Apify esegue anche codice personalizzato, pianificazioni ospitate e scraper di altri siti Web.

### Mantieni piccole le ricerche di un solo video

Passa un video ID e ricevi direttamente i metadati. Utilizza l'accesso con pagamento in base al consumo quando il lavoro non richiede un abbonamento alla piattaforma o una scansione dei canali.

### Mantieni il modello dati della tua applicazione

Mappa i campi effettivamente letti dalla tua app. Conserva i conteggi null, mantieni esplicite le date di pubblicazione e salva un array JSON per i consumatori che hanno letto in precedenza gli elementi del set di dati.

### Mantieni la scoperta separata dall’arricchimento

Continua un utile flusso di lavoro di scoperta, deduplica il suo video IDs, quindi arricchisci solo i video di cui il tuo prodotto ha bisogno con FlashData.

<a id="actors"></a>
## Non esiste un prezzo unico Apify YouTube

Gli autori degli attori scelgono input, output e modelli di prezzo. Questi tre attori utilizzano eventi in base al risultato, ma hanno capacità diverse. I prezzi riportati di seguito sono USD per 1,000 video restituiti.

| Attore | Gratuito / 1,000 video | Starter | Scale | Business | Sceglilo per |
| --- | --- | --- | --- | --- | --- |
| streamers/youtube-scraper | $4.00 | $3.00 | $2.60 | $2.40 | Video URLs, scoperta e sottotitoli esistenti opzionali. Questo è l’attore della calcolatrice. |
| streamers/youtube-channel-scraper | $1.30 | $1.00 | $0.80 | $0.50 | Scoperta del canale con dati video di base. Non è una ricerca completa di metadati per un ID arbitrario. |
| apidojo/youtube-scraper | $0.50 | $0.50 | $0.50 | $0.50 | Ingressi di scoperta. Il suo attuale README esclude URLs video singoli e richiede almeno 10 video per input. Demo gratuita: 5 corre/mese, al massimo 10 elementi/run. |

Piani mensili self-service: da Starter corrisponde a Bronze, da Scale a Silver e da Business a Gold. Gli attori più economici della scoperta non vengono sostituiti nel calcolatore del video noto.

### Controlla l'evento fatturabile

Apify supporta modelli pay-per-event, pay-per-usage e combinati. Per gli streamer/youtube-scraper, conta gli eventi dei risultati e i componenti aggiuntivi selezionati; non aggiungere automaticamente una tariffa di calcolo generica. Esamina la ripartizione degli eventi della tua corsa di attori.

### Separa i sottotitoli esistenti dalla trascrizione AI

L'attore principale può includere i sottotitoli esistenti nel risultato. La sua trascrizione AI viene fatturata per minuto iniziato per video: su Starter, un video di 10 minuti aggiunge $0.41 prima dell'evento risultato $0.003. Anche i riepiloghi AI, le descrizioni e il filtro delle date dei canali hanno i propri prezzi degli eventi. FlashData recupera le tracce esistenti; non genera didascalie mancanti.

### Mantieni la scoperta separata dall’arricchimento

Utilizza il video noto IDs quando è già presente nella tua app. Una scansione di scoperta può restituire video che non usi mai. Scoperta del budget ed eventuale successivo arricchimento separatamente.

<a id="costs"></a>
## Confronta le tariffe unitarie e le tariffe mensili

USD, piani di elenco mensili. Questo modello utilizza l'evento risultato di streamer/youtube-scraper, un video restituito per input ID, con filtro della data e componenti aggiuntivi AI disattivati. I sottotitoli esistenti utilizzano l'impostazione ALWAYS_SUBTITLES; i metadati più le didascalie sono un risultato dell'attore ma due richieste FlashData. I prezzi FlashData provengono dal catalogo dati YouTube corrente. L'intero saldo incluso di ciascun piano viene allocato a questo flusso di lavoro prima che venga aggiunto un utilizzo aggiuntivo. Apify Fermate gratuite al suo budget $5; i piani a pagamento aggiungono un utilizzo superiore al budget incluso. FlashData gli acquisti con saldo zero includono la sua ricarica minima $10 quando è necessario credito aggiuntivo. Sono escluse tasse, sconti annuali, altri Attori, spese di deposito separato/export e tentativi di failed. A zero video, un piano a pagamento selezionato ha ancora il suo canone mensile; il costo effettivo per video non è definito.

### Apify piani della piattaforma

| Piano Apify | Canone mensile | Utilizzo/mese incluso | Attore principale / 1,000 video | Video entro questo budget |
| --- | --- | --- | --- | --- |
| Gratis | $0.00 | $5.00 | $4.00 | 1,250 |
| Starter | $19.00 | $19.00 | $3.00 | 6,333 |
| Scale | $199.00 | $199.00 | $2.60 | 76,538 |
| Business | $999.00 | $999.00 | $2.40 | 416,250 |

Questi conteggi assegnano l'intero budget agli eventi risultanti senza componenti aggiuntivi o altro utilizzo della piattaforma. Se mantieni Apify per altri Attori, il suo abbonamento rimane; confronta l'utilizzo incrementale con il budget rimanente.

### FlashData YouTube Piani dati

| Piano FlashData | Per 1,000 richieste | Canone mensile | Richieste incluse al mese |
| --- | --- | --- | --- |
| Pagamento a consumo | $0.50 | $0.00 | 0 |
| Micro | $0.40 | $49.00 | 125,000 |
| Starter | $0.35 | $199.00 | 571,428 |
| Pro | $0.30 | $499.00 | 1,666,666 |
| Scale | $0.25 | $999.00 | 4,000,000 |
| Business | $0.20 | $1,999.00 | 10,000,000 |

Queste sono velocità dati standard di YouTube. La ricerca estesa e il download hanno prezzi separati. [Prezzo intero](https://flashdata.dev/it/pricing/youtube-data).

### Esempi realizzati

FlashData paga in base al consumo rispetto a Apify Starter e streamer/youtube-scraper. I metadati più i sottotitoli esistenti rappresentano un evento risultato attore, ma due richieste FlashData. Si tratta di stime sull'utilizzo e sui costi mensili, non di richieste di campi di risposta identici.

| Video | Flusso di lavoro | FlashData richieste | FlashData utilizzo modellato | Utilizzo dell'evento dell'attore | Apify costo mensile comprensivo di canone |
| --- | --- | --- | --- | --- | --- |
| 1,000 | Metadati per video conosciuti IDs | 1,000 | $0.50 | $3.00 | $19.00 |
| 1,000 | Metadati + didascalie esistenti | 2,000 | $1.00 | $3.00 | $19.00 |
| 10,000 | Metadati per video conosciuti IDs | 10,000 | $5.00 | $30.00 | $30.00 |
| 10,000 | Metadati + didascalie esistenti | 20,000 | $10.00 | $30.00 | $30.00 |
| 100,000 | Metadati per video conosciuti IDs | 100,000 | $50.00 | $300.00 | $300.00 |
| 100,000 | Metadati + didascalie esistenti | 200,000 | $100.00 | $300.00 | $300.00 |

Gli acquisti di FlashData dal saldo zero hanno una ricarica minima di $10. La tariffa di Apify contiene già l'utilizzo incluso; non aggiungere quell'utilizzo due volte. Il calcolatore HTML ti consente di scegliere entrambi i piani in modo indipendente.

### Accesso gratuito

Apify Free ha un budget condiviso mensile di $5; Possono essere applicate anche restrizioni sulla demo dei singoli attori. L'attore Dojo API mostrato sopra limita gratuitamente a cinque sessioni demo al mese e dieci elementi per sessione.

I registri verificati eleggibili FlashData possono ricevere un'indennità iniziale fino alle richieste di dati 4,000 standard YouTube. Questo non resetta mensile.

<a id="migration"></a>
## Conservare il lettore del set di dati; sostituire una ricerca

Inizia con un video pubblico noto ID. L'esempio scrive i campi Actor familiari selezionati come un array JSON e salva la risposta completa FlashData separatamente.

### 1. Configura l'accesso e mappa la richiesta

Crea o riutilizza una chiave con autorizzazione youtube_metadata in [API Chiavi](https://flashdata.dev/app/api-keys) e seleziona [crediti disponibili](https://flashdata.dev/app/billing). Gli agenti devono prima riutilizzare l'accesso o utilizzare una prova idonea. Tieni le chiavi fuori dalla chat.

Chiamata attore esistente, per riferimento alla migrazione:

```bash
# The existing Actor call, shown for migration reference.
curl --fail-with-body --silent --show-error --max-time 310 \
  --request POST \
  'https://api.apify.com/v2/acts/streamers~youtube-scraper/run-sync-get-dataset-items' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"startUrls":[{"url":"https://www.youtube.com/watch?v=FUfGcZ092b0"}],
    "maxResults":1,"maxResultsShorts":0,"maxResultStreams":0,
    "transcriptionAndSubtitle":"NONE","aiVideoDescription":false,"aiVideoSummary":false}'
```

FlashData JSON corpo per POST /v1/queries/realtime:

```json
{
  "source": "youtube_metadata",
  "video_id": "FUfGcZ092b0",
  "params": {
    "include_formats": false,
    "include_chapters": true
  }
}
```

L'endpoint di sincronizzazione dell'attore può già restituire elementi in una risposta HTTP. Migrare la richiesta, la busta e i campi; non aggiungere polling non necessari.

### 2. Salva lo script, quindi eseguilo

Scegli Python o Bash. Ogni nuova cartella di output invia una richiesta. Il riutilizzo della cartella legge l'output salvato; interrotto o failed tentativi di arresto per ispezione. Entrambe le versioni utilizzano gli stessi file.

#### Python

Richiede Python 3.10+. Installa la dipendenza con python -m pip install requests. In una nuova cartella di lavoro, salva lo script completo seguente come video-lookup.py prima di eseguirlo.

```python
import argparse
import getpass
import json
import math
import os
import re
from pathlib import Path

import requests

parser = argparse.ArgumentParser()
parser.add_argument("video_id")
parser.add_argument("folder", type=Path)
args = parser.parse_args()
if not re.fullmatch(r"[A-Za-z0-9_-]{11}", args.video_id):
    raise SystemExit("Use an 11-character YouTube video ID")
body = {"source": "youtube_metadata", "video_id": args.video_id,
        "params": {"include_formats": False, "include_chapters": True}}
out = args.folder
if not out.exists():
    key = os.environ.get("FLASHDATA_API_KEY") or getpass.getpass("FlashData API key: ")
    if not key.strip():
        raise SystemExit("An API key is required")
    out.mkdir(parents=True)
    (out / "request.json").write_text(json.dumps(body), encoding="utf-8")
    try:
        response = requests.post(
            "https://data.flashdata.dev/v1/queries/realtime", json=body,
            headers={"X-API-Key": key, "Accept": "application/json"},
            timeout=120, allow_redirects=False,
        )
    except requests.RequestException:
        raise SystemExit("Outcome unknown. Keep this folder and check History before retrying.")
    (out / "response.json").write_bytes(response.content)
    (out / "http-status.txt").write_text(str(response.status_code), encoding="utf-8")
    (out / "retry-after.txt").write_text(response.headers.get("Retry-After", ""), encoding="utf-8")
else:
    print("Reading saved output; no API call.")

try:
    saved = json.loads((out / "request.json").read_text(encoding="utf-8"))
    status = (out / "http-status.txt").read_text(encoding="utf-8").strip()
except (OSError, ValueError):
    raise SystemExit("Incomplete attempt. Inspect this folder and History before retrying.")
if saved != body:
    raise SystemExit("This folder belongs to a different request. Use a new folder.")
if status != "200":
    raise SystemExit(f"HTTP {status}: inspect response.json and retry-after.txt")
data = json.loads((out / "response.json").read_text(encoding="utf-8"))
if not isinstance(data, dict) or data.get("status") != "done" or data.get("source") != body["source"]:
    raise SystemExit("Request did not complete successfully; inspect response.json")
items = data.get("results")
if not isinstance(items, list) or len(items) != 1 or not isinstance(items[0], dict):
    raise SystemExit("Expected one metadata result")
item = items[0]
if item.get("videoId") != args.video_id:
    raise SystemExit("Returned video does not match the request")
seconds = item.get("duration")
duration = None
if seconds is not None:
    if type(seconds) not in (int, float) or not math.isfinite(seconds) or seconds < 0:
        raise SystemExit("Invalid duration")
    whole = int(seconds)
    duration = f"{whole // 3600:02d}:{whole % 3600 // 60:02d}:{whole % 60:02d}"
mapped = [{
    "id": item["videoId"],
    "url": "https://www.youtube.com/watch?v=" + item["videoId"],
    "title": item.get("title"), "text": item.get("description"),
    "channelName": item.get("channel"), "channelId": item.get("channelId"),
    "viewCount": item.get("viewCount"), "likes": item.get("likeCount"),
    "commentsCount": item.get("commentCount"), "duration": duration,
    "uploadDateRaw": item.get("uploadDate"),
    "captionLanguages": item.get("transcriptLanguages"),
}]
(out / "dataset-items.json").write_text(
    json.dumps(mapped, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
)
print(f"Saved {out}/dataset-items.json; actual usage: {json.dumps(data.get('usage'))}")

```

Esegui da quella cartella, sostituendo ID con un video pubblico dal tuo set di dati:

```bash
python video-lookup.py FUfGcZ092b0 video-001
```

#### Bash

Richiede Bash, cURL 7.76+ e jq 1.6+. Salva lo script completo di seguito come video-lookup.sh nella tua cartella di lavoro:

```bash
#!/usr/bin/env bash
set -euo pipefail
video_id="${1:?Use: VIDEO_ID OUTPUT_FOLDER}"
out="${2:?Set OUTPUT_FOLDER}"
[[ "$video_id" =~ ^[A-Za-z0-9_-]{11}$ ]] || { echo 'Invalid video ID' >&2; exit 1; }
body=$(jq -n --arg id "$video_id" '{source: "youtube_metadata", video_id: $id,
  params: {include_formats: false, include_chapters: true}}')
if [[ ! -e "$out" ]]; then
  if [[ -z "${FLASHDATA_API_KEY:-}" ]]; then
    read -r -s -p 'FlashData API key: ' FLASHDATA_API_KEY; printf '\n'
  fi
  : "${FLASHDATA_API_KEY:?An API key is required}"
  mkdir -p -- "$out"
  printf '%s\n' "$body" > "$out/request.json"
  curl --fail-with-body --silent --show-error --max-time 120 \
    --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
    --header "X-API-Key: $FLASHDATA_API_KEY" \
    --header 'Content-Type: application/json' --header 'Accept: application/json' \
    --data-binary "@$out/request.json" --output "$out/response.json" \
    --dump-header "$out/response-headers.txt" --write-out '%{http_code}' \
    > "$out/http-status.txt" || {
      printf 'Request failed. Keep this folder and inspect History before retrying.\n' >&2
      exit 1
    }
else
  printf 'Reading saved output; no API call.\n'
fi
jq -e --argjson expected "$body" '. == $expected' "$out/request.json" >/dev/null
[[ "$(cat "$out/http-status.txt")" == 200 ]] || {
  printf 'Inspect the saved status, response and Retry-After header.\n' >&2; exit 1;
}
mapped=$(jq -e --arg id "$video_id" '
  def pad: tostring | if length < 2 then "0" + . else . end;
  def hms:
    if . == null then null
    elif type != "number" then error("Invalid duration")
    elif (isfinite | not) or . < 0 then error("Invalid duration")
    else floor | [(./3600 | floor | pad), ((.%3600)/60 | floor | pad), (.%60 | pad)] | join(":") end;
  if .source != "youtube_metadata" or .status != "done" then error("Request not done") else . end
  | .results | if type != "array" then error("Expected results")
    elif length != 1 then error("Expected one result") else .[0] end
  | if .videoId != $id then error("Wrong video") else . end
  | [{id: .videoId, url: ("https://www.youtube.com/watch?v=" + .videoId),
      title, text: .description, channelName: .channel, channelId,
      viewCount, likes: .likeCount, commentsCount: .commentCount,
      duration: (.duration | hms), uploadDateRaw: .uploadDate,
      captionLanguages: .transcriptLanguages}]' "$out/response.json")
printf '%s\n' "$mapped" > "$out/dataset-items.json"
printf 'Saved %s/dataset-items.json; actual usage: ' "$out"
jq -c '.usage' "$out/response.json"

```

Esegui da quella cartella:

```bash
bash video-lookup.sh FUfGcZ092b0 video-001
```

### 3. Leggi l'output salvato

video-001/dataset-items.json è un array per il lettore di applicazioni. response.json mantiene il risultato e l'utilizzo originali. Questo è un adattatore di campo, non il Apify Dataset API. Non crea un dataset ID, popola metriche sconosciute o fabbrica commenti o campi di monetizzazione.

Illustrativo dataset-items.json:

```json
[
  {
    "id": "FUfGcZ092b0",
    "url": "https://www.youtube.com/watch?v=FUfGcZ092b0",
    "title": "Example video",
    "text": "Example description",
    "channelName": "Example channel",
    "channelId": "UC_EXAMPLE",
    "viewCount": 1200,
    "likes": null,
    "commentsCount": null,
    "duration": "00:03:17",
    "uploadDateRaw": "2025-01-15",
    "captionLanguages": [
      "en",
      "es"
    ]
  }
]
```

| Campo Attore esistente | FlashData metadati | Azione migratoria |
| --- | --- | --- |
| ID/URL | videoId | Mantieni l'ID e costruisci l'orologio canonico YouTube URL. |
| titolo/testo | titolo/descrizione | Mappa la descrizione sul testo se il tuo lettore si aspetta il nome del campo dell'attore. |
| channelName / channelId | canale / channelId | Conserva il nome e ID. Non dedurre un handle di canale dal nome visualizzato. |
| Mi piace / commentsCount / viewCount | likeCount / commentCount / viewCount | Mantieni i valori mancanti come null. Una metrica mancante non è zero. |
| durata, spesso HH:MM:SS | durata in secondi | L'esempio converte i secondi in una stringa HH:MM:SS, mantenendo null. |
| data, che può essere assoluta o relativa | uploadDate | L'esempio mantiene uploadDateRaw. Aggiungi il tuo parser di data prima di inserire una data normalizzata. |
| sottotitoli[] / transcriptionUrl | Una richiesta youtube_transcript o youtube_captions separata | Le tracce esistenti e la sintesi vocale generata rappresentano input diversi per la tua app. |
| Campi di arricchimento solo per attori | Nessun equivalente automatico | Mantieni una fase di arricchimento separata per commenti, espansione del canale e analisi generate dall'intelligenza artificiale. |

[Schema dei metadati](https://flashdata.dev/it/docs/sources/youtube_metadata/reference.md).

### Riporta l'intento dei sottotitoli

| Ingresso dell'attore principale | FlashData migrazione |
| --- | --- |
| ALWAYS_SUBTITLES | Aggiungi una richiesta youtube_transcript o youtube_captions separata per le tracce esistenti. |
| subtitlesLanguage | Usa params.language. Un array fino a 10 lingue restituisce tracce più errori per lingua. |
| preferAutoGeneratedSubtitles | Questa è una preferenza. FlashData params.auto seleziona rigorosamente i sottotitoli generati da YouTube o forniti dall'uploader, senza fallback multiorigine. |
| TRANSCRIPTION_AS_FALLBACK / ALWAYS_TRANSCRIBE | Mantieni separata la sintesi vocale dal testo; FlashData non genera una traccia mancante. |
| sottotitoli[].srt / transcriptionUrl | Mappa segmenti con timestamp o formatta un file in modo esplicito. Un testo normale generato URL non è un array di segmenti con timestamp. |

[Ricetta per i sottotitoli con timestamp](https://flashdata.dev/it/docs/guides/timestamped-captions-recipe/reference.md).

<a id="production"></a>
## Set di dati, lavori e pianificazioni di lunga durata da running

Se i tuoi strumenti dipendono dal set di dati Apify IDs e dalle pianificazioni, mantieni un attore personalizzato come orchestratore: chiama FlashData al suo interno e scrivi gli elementi mappati nel suo set di dati. Budget il tempo di esecuzione e lo spazio di archiviazione dell'attore insieme all'utilizzo di FlashData. La calcolatrice sopra i modelli dirige le chiamate FlashData.

| Preoccupazione | Apify | FlashData |
| --- | --- | --- |
| Richiesta | Attore ID + opzioni build/input; attività salvata opzionale | sorgente + video_id + parametri; nessuna build di attore o opzioni di memoria |
| Risultato sincrono | run-sync-get-dataset-items restituisce un array di elementi; il suo limite documentato di HTTP è 300 secondi | La risposta in tempo reale ha stato, risultati[] e utilizzo; estrarre i risultati prima di mappare i campi |
| Lavoro lungo running | Avvia una corsa, salva la corsa ID, attendi lo stato del terminale, leggi defaultDatasetId | Invia un lavoro async o batch, salva il suo ID, interroga il suo stato e recupera il suo risultato |
| Archiviazione dell'output | Elementi del set di dati più record di valori-chiave facoltativi a cui fa riferimento URL | Salva la risposta o esportala nel tuo archivio durevole; un set di dati Apify ID non è un lavoro FlashData ID |
| Lavoro ricorrente | Apify Inizio programma Attori/Tasks; i webhook avvisano i consumatori a valle | Utilizza l'applicazione, il cron, il CI o l'host dell'agente per chiamare FlashData; migrare insieme il programma e il consumatore |

### Sposta un set di dati esistente

Esporta ogni pagina del set di dati esistente prima di cambiare produttore. Mantieni i file dei sottotitoli di riferimento di cui hai ancora bisogno. Non rieseguire un attore solo per scaricare l'output già raccolto.

[Salvare e riutilizzare i risultati](https://flashdata.dev/it/docs/guides/save-results/reference.md)

### Aggiorna una libreria video

Deduplica il video IDs, controlla ogni risultato e mantieni l'input-to-output IDs. Utilizza l'elaborazione batch o in blocco per elenchi più grandi; riprovare failed elementi dopo averne controllato gli errori.

[Riferimento all'elaborazione in blocco](https://flashdata.dev/it/docs/reference/bulk-processing/reference.md)

### Mantieni prevedibile il lavoro programmato

Riporta fuso orario, cadenza, credenziali e destinazione di output. Registra una finestra di pianificazione di completed prima di mandare in pensione il vecchio produttore, in modo che le pianificazioni sovrapposte non creino lavoro duplicato.

[Esegui attività ricorrenti](https://flashdata.dev/it/docs/guides/recurring-tasks/reference.md)

### Lista di controllo del taglio

1. Registra l'attore esatto, la build, l'input dell'attività, gli eventi fatturabili, i campi di output e il consumatore a valle.
2. Svuota le esecuzioni esistenti ed esporta tutte le pagine del set di dati. clean=true può saltare i record, quindi una breve pagina da sola non è la prova che l'esportazione è completa; controllare i metadati di impaginazione.
3. Verifica l'adattatore rispetto a IDs salvati, inclusi i parametri null, le date e l'origine dei sottotitoli.
4. Sposta la cadenza, il fuso orario e la destinazione nel tuo runner. Mantenere i checkpoint. maxTotalChargeUsd non è un limite di spesa per la chiave FlashData API; aggiungere controlli di spesa a livello di applicazione.
5. Cambia il produttore per la finestra di pianificazione successiva senza esecuzioni duplicate. Preservare le esportazioni. Interrompere il lavoro ricorrente su credenziali revocate o saldo insufficiente.

<a id="agents"></a>
## Codificazione e agenti personali

Gli agenti idonei possono iniziare con le richieste di dati 1 credit (fino alle richieste 100 standard YouTube) per le ore 72. I metadati e le didascalie condividono l'indennità.

1. Identificare l'integrazione dell'attore e riutilizzare prima una credenziale FlashData esistente.
2. Prova una ricerca video e salva sia l'output grezzo che quello mappato con l'utilizzo effettivo.
3. Il proprietario accede o si registra, verifica l'e-mail e approva le richieste, gli ambiti e l'accesso al saldo condiviso. I crediti di prova inutilizzati non vengono trasferiti.
4. Mantieni le credenziali del proprietario per un uso ricorrente. Stop alla revoca; non creare nuove prove.

```text
Replace this project's Apify YouTube metadata lookup with FlashData.
Read https://flashdata.dev/auth.md and https://flashdata.dev/docs/sources/youtube_metadata/reference.md.
Identify the exact Actor ID, build, input, output fields, schedule and storage consumer first.
Reuse a saved FlashData credential or start one eligible trial with youtube_metadata permission.
Run one known video ID. Save the raw response, actual usage and a mapped JSON item array.
Keep null metrics and preserve the raw publication date. Do not invent Actor-only fields.
Keep channel discovery, comments, AI transcription and hosted scheduling separate unless explicitly migrated.
Reuse saved results after restart. Ask the owner to claim before recurring use and store keys outside chat.
Stop after revocation or insufficient balance; never create more trials to continue.
```

[Processo e rivendicazione](https://flashdata.dev/it/docs/guides/agent-onboarding/reference.md) · [Autonomo CLI](https://flashdata.dev/it/docs/guides/flashdata-cli/reference.md) · [MCP installazione](https://flashdata.dev/it/docs/integrations/mcp-clients/reference.md)

<a id="faq"></a>
## Prima di cambiare

### È un sostituto della piattaforma Apify?

Sostituisce chiamate dati specifiche YouTube nel flusso di lavoro. Apify fornisce anche un marketplace di attori, tempi di esecuzione personalizzati, pianificazioni ospitate e spazio di archiviazione. Mantieni quelle parti dove le usi o trasferisci le loro responsabilità nella tua applicazione.

### Perché non confrontare tutti gli attori allo stesso prezzo?

Gli sviluppatori degli attori scelgono diversi modelli di prezzo, output e restrizioni di input. Il calcolatore utilizza gli streamer/youtube-scraper. La tabella degli attori include anche un attore di scoperta più economico; le sue restrizioni su singolo video sono importanti quando si sostituisce una ricerca su richiesta.

### Un abbonamento da Apify viene addebitato due volte per l'utilizzo incluso?

No. La tariffa del piano include un budget di utilizzo prepagato. Il calcolatore sottrae tale budget prima di aggiungere ulteriore utilizzo dell'attore. Si presuppone che l'intero budget sia disponibile per questo flusso di lavoro. Se altri attori lo consumano, ne rimane meno per YouTube.

### Posso mantenere un consumatore di set di dati di Apify?

L'esempio scrive un array JSON con nomi di campi familiari selezionati. Non crea un set di dati Apify né esegue ID. Leggi direttamente il nuovo file, pubblicalo tramite il tuo spazio di archiviazione o mantieni un attore personalizzato che scrive questi elementi mappati nel suo set di dati per il tuo consumatore esistente.

### Cosa succede ai sottotitoli e alla trascrizione AI?

L'attore principale di Apify offre sottotitoli esistenti e trascrizione AI opzionale. FlashData recupera le tracce YouTube esistenti. Richiedi metadati e didascalie separatamente, controlla la lingua e l'origine restituite e mantieni separati tutti i passaggi di sintesi vocale o di riepilogo AI.

### Il mio programma o limite di spesa esistente verrà trasferito?

No. Ricrea il programma nel corridore scelto e aggiungi un controllo del budget a livello di applicazione. Un'impostazione Apify maxTotalChargeUsd non è un limite di spesa per la chiave FlashData API. Le chiavi del proprietario utilizzano il saldo dell'account condiviso.
