Salta al contenuto
IT
Ottieni la chiave API
Sfoglia la documentazione

Riferimento API

YouTube Download API

Ottieni una chiave API

Scarica il video o l'audio YouTube sul tuo storage cloud. Scegliere risoluzione, formato e durata della clip, quindi monitorare il lavoro asincrono attraverso il completamento.

API per scaricare video YouTube — esempi Python

Crea una richiesta

L’ID di 11 caratteri presente nell’URL del video, non l’URL completo.

Opzioni multimediali avanzate

Un selettore di formato sovrascrive la qualità, il frame rate e la selezione audio-lingue. Il formato di uscita e i limiti di clip ancora si applicano. L'estremità della clip deve seguire l'inizio; o il limite può essere omesso.

Destinazione di stoccaggio

Blank utilizza la data di caricamento UTC (YYYYYMMDD).

Aggiungi le credenziali di archiviazione sul server prima di eseguire il codice. Hanno bisogno del permesso per caricare i file.

Requisiti di archiviazione e credenziali del fornitore
Complemento webhookWebhook payload, verifica e ripiani

Markdown si applica ai risultati completati. I ricevimenti e lo stato di lavoro mantengono i loro campi originali.

POSThttps://data.flashdata.dev/v1/queries
import gzip
import json
import random
import time
import urllib.error
import urllib.request

api_key = "YOUR_API_KEY"
payload = {
    "source": "youtube_download",
    "video_id": "jNQXAC9IVRw",
    "params": {
        "download_type": "audio_video",
        "video_quality": "<=720",
        "audio_language": "default",
        "upload_metadata": False,
        "output_format": "mp4",
        "storage": {
            "storage_type": "s3",
            "storage_url": "your-media-bucket",
            "access_key": "YOUR_ACCESS_KEY",
            "secret_key": "YOUR_SECRET_KEY",
            "region": "us-east-1",
        },
    },
}

def api_get(url):
    request = urllib.request.Request(url, headers={"X-API-Key": api_key})
    with urllib.request.urlopen(request, timeout=60) as response:
        return json.load(response), response.headers

class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, request, file_pointer, code, message, headers, new_url):
        return None

def read_result(url):
    request = urllib.request.Request(url, headers={"X-API-Key": api_key})
    try:
        with urllib.request.build_opener(NoRedirect).open(request, timeout=60):
            raise RuntimeError("Expected a result redirect")
    except urllib.error.HTTPError as response:
        if response.code != 302 or not response.headers.get("Location"):
            raise
        storage_url = response.headers["Location"]
        response.close()
    # Never forward the API key to storage.
    with urllib.request.urlopen(urllib.request.Request(storage_url, headers={"Accept-Encoding": "gzip"}), timeout=60) as response:
        content = response.read()
        if response.headers.get("Content-Encoding") == "gzip":
            content = gzip.decompress(content)
        return json.loads(content)

def link(job, relation):
    return next(item["href"] for item in job["links"] if item["rel"] == relation)

request = urllib.request.Request(
    "https://data.flashdata.dev/v1/queries",
    data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
    headers={"Content-Type": "application/json", "X-API-Key": api_key},
    method="POST",
)
with urllib.request.urlopen(request, timeout=120) as response:
    submission = json.load(response)
jobs = submission.get("queries", [submission])
for submitted in jobs:
    print("Job:", submitted["id"])
    deadline = time.monotonic() + 300
    while time.monotonic() < deadline:
        status, headers = api_get(link(submitted, "self"))
        job = status.get("job", status)
        if job["status"] == "completed":
            result = job.get("result") if submitted["source"] == "youtube_download" and job.get("result") is not None else read_result(link(submitted, "results"))
            print(json.dumps(result, ensure_ascii=False, indent=2))
            break
        if job["status"] == "failed":
            raise RuntimeError(f"{submitted['id']}: {job.get('error', 'Job failed')}")
        hint = headers.get("Retry-After", "1")
        delay = max(1, min(5, int(hint))) if hint.isdigit() else 5
        time.sleep(min(delay * random.uniform(1, 1.2), max(0, deadline - time.monotonic())))
    else:
        raise TimeoutError(f"Still running; save this job ID: {submitted['id']}")
Ricevuta di lavoro, poi sondaggio per i risultatiautenticazione X-API-Key

Parametri

Invia source e video_id al livello superiore. Le opzioni di origine appartengono in params. I campi opzionali possono essere omessi.

Corpo della richiesta

sourcestring / Obbligatorio
Impostare su youtube_download.
video_idstring / Obbligatorio
Il video 11-character YouTube video ID, come FUfGcZ092b0. Accetta lettere, numeri, sottolineature e trattini.
Esattamente. 11 caratteriPredefinito: Non impostato
Formato accettato^[A-Za-z0-9_-]{11}$
paramsobject / Obbligatorio
Settings per questa richiesta.
callback_urlstring · nullable / Facoltativo
Async e solo lotto. Completamento HTTPS pubblico URL sulla porta 443, fino a caratteri 2,048. Nessuna credenziali utente o frammentazione URL. Omit, utilizzare null o una stringa vuota per nessuna notifica. In un lotto, impostare questo su ogni query, param esterni.
Predefinito: Non impostato

Video e audio

params.download_typestring / Facoltativo
audio_video unisce video e audio; il video seleziona solo video; l'audio seleziona solo l'audio.
1 a 11 caratteriValori: audio_video / video / audioPredefinito: "audio_video"
params.video_qualitystring / Facoltativo
Selezione della risoluzione video. Omit per i download audio-solo.
1 a 40 caratteriValori: best / worst / <=144 / ==144 / >=144 / <=360 / ==360 / >=360 / <=480 / ==480 / >=480 / <=720 / ==720 / >=720 / <=1080 / ==1080 / >=1080 / <=1440 / ==1440 / >=1440 / <=2160 / ==2160 / >=2160 / <=4320 / ==4320 / >=4320Predefinito: "<=720"
params.fpsstring / Facoltativo
Limiti di frame-rate: >=, <= o == seguito da un valore da 1 a 240. Omit per i download audio-solo.
1 a 6 caratteriPredefinito: Non impostato
Formato accettato^(?:>=|<=|==)(?:[1-9]\d?|1\d\d|2[0-3]\d|240)$
params.audio_languagestring / Facoltativo
Selezione audio. Riguarda audio_video e audio.
1 a 8 caratteriValori: default / originalPredefinito: "default"
params.audio_qualitystring / Facoltativo
Solo bitrate audio in kbps, o meglio. Le scelte numeriche devono essere inviate come stringhe. Omit per i download video.
1 a 10 caratteriValori: best / 320 / 256 / 192 / 128Predefinito: "best"
params.output_formatstring / Facoltativo
Video: mp4, webm o mkv. Audio: m4a, mp3 o opus.
1 a 10 caratteriValori: mp4 / webm / mkv / m4a / mp3 / opusPredefinito: mp4 (video) / m4a (audio)
params.yt_dlp_formatstring / Facoltativo
Selettore di formato avanzato, da 1 a caratteri 1,024 dopo la rifilatura dello spazio bianco. I caratteri di controllo sono respinti. Sovrascrive video_quality, fps e audio_language, i cui valori vengono quindi ignorati; il formato di output e la clipping si applicano ancora.
1 a 1024 caratteriPredefinito: Non impostato
params.upload_metadataboolean / Facoltativo
Caricare un file di metadati JSON accanto al file multimediale nel vostro storage.
true o falsePredefinito: false

Clipping

params.start_atstring / Facoltativo
Avvio clip in H:MM:SS o HH:MM:SS formato, da 00:00:00 a 12:00:00. Predefinisce 00:00:00 quando viene fornito solo end_at.
1 a 8 caratteriPredefinito: Non impostato
Formato accettato^\d{1,2}:[0-5]\d:[0-5]\d$
params.end_atstring / Facoltativo
Clip end in H:MM:SS o HH:MM:SS formato, fino a 12:00:00. Deve essere più tardi di start_at.
1 a 8 caratteriPredefinito: Non impostato
Formato accettato^\d{1,2}:[0-5]\d:[0-5]\d$

Destinazione di stoccaggio

params.storageobject / Obbligatorio
Destinazione per i file multimediali completati. Sono accettati solo i campi di stoccaggio elencati.
params.storage.storage_typestring / Obbligatorio
Fornitore di stoccaggio: s3, s3_compatible, oss, gcs, azure, cos, bos o tos.
params.storage.storage_urlstring / Obbligatorio
Secchio non vuoto o nome contenitore, fino a caratteri 1,024. Lo spazio bianco circostante è rimosso. Per s3, utilizzare un nome di secchio AWS valido senza un percorso URL o cartella; le cartelle appartengono a object_prefix.
params.storage.object_prefixstring / Facoltativo
Prefisso chiave degli oggetti, caratteri 1 a caratteri 512. Ogni segmento separato da slitta accetta lettere, cifre, punti, sottoscore e trattini; segmenti vuoti, . e .. sono respinti. Non c'e' nessun guinzaglio. Circondare lo spazio bianco e uno slash trailing sono rimossi. YYYYMMDD utilizza la data di caricamento UTC, incluso in archive/YYYYMMDD.
Predefinito: "YYYYMMDD"
params.storage.access_keystring / Facoltativo
Chiave di accesso per S3, compatibile con S3, OSS, COS, BOS o TOS; abbinata a secret_key.
params.storage.secret_keystring / Facoltativo
Chiave segreta per S3, compatibile con S3, OSS, COS, BOS o TOS.
params.storage.endpoint_urlstring / Facoltativo
endpoint HTTPS pubblico per lo storage compatibile S3 o OSS. COS, BOS e TOS lo derivano dalla regione.
params.storage.regionstring / Facoltativo
Richiesto per COS, BOS e TOS; anche fornire per i download compatibili S3 e S3. I nomi dei benne COS includono l'APPID.
params.storage.service_accountobject / Facoltativo
account di servizio GCS: project_id, client_email e PEM private_key.
params.storage.account_namestring / Facoltativo
Nome dell'account di archiviazione Azure. Utilizzare il nome del contenitore in storage_url.
params.storage.sas_tokenstring / Facoltativo
Azure contenitore SAS con scadenza e firma.

Risposta

Il costruttore di richieste invia i download con Async o Batch e richiede params.storage. HTTP 200 con status: pending conferma l'accettazione, non la consegna. Batch restituisce una ricevuta di lavoro per video ID.

Soppressione usage.credits è 0. I download vengono fatturati tramite il volume dei media consegnati dopo la consegna di successo; i file di metadati facoltativi non aggiungono alle spese di download.

Polloncino job.status fino a quando completed, quindi recuperare il risultato JSON. Leggi i dettagli dei media results[0], incluso l'oggetto caricato file_url, dimensione del file e checksum.

Leggi il risultato

Dopo il completamento del lavoro, salvare la JSON dal suo link di risultati come response.json. Salvare questo come read-response.py ed eseguire pitone read-response.py. Legge i dettagli del file senza scaricare i supporti o fare un'altra richiesta.

read-response.py
import json
from pathlib import Path

response = json.loads(Path("response.json").read_text(encoding="utf-8-sig"))
if response.get("status") not in ("done", "completed") or not isinstance(response.get("results"), list):
    raise SystemExit("Expected completed result JSON; inspect the response or job status.")
if not response["results"]:
    print("[]")
    raise SystemExit(0)
result = response["results"][0]

output = {name: result.get(name) for name in (
    "file_url", "file_size", "md5", "duration", "output_format"
)}
# Use your storage credentials to access the media at file_url.
print(json.dumps(output, ensure_ascii=False, indent=2))

Stato può includere i dettagli dei media in job.result. I flussi di lavoro di default JSON li usano quando disponibili e altrimenti seguono rel: results link; non assumere un risultato in linea è sempre presente.

Tutti i campi di risposta
Campo di applicazioneDesignazione
idstringScaricare il lavoro ID.
sourcestringyoutube_download.
statusstringin attesa di accettare il lavoro.
created_atstringTempo di creazione di lavoro in formato ISO 8601.
usage.creditsnumber0 alla presentazione. I download vengono caricati dal volume dei dati consegnato dopo il completamento.
linksarraySeguire l'auto link per lo stato del lavoro e il link dei risultati per l'output completato.
links[].relstringauto o risultati.
links[].hrefstringURL per eseguire query con la stessa chiave API.
links[].methodstringGET.
Campi di file multimediali completi
Campo di applicazioneDesignazione
results[0].file_urlstringPosizione del file multimediale nel tuo storage.
results[0].file_sizeintegerFormato dei file multimediali in byte.
results[0].downloaded_bytesintegerConsegnati byte multimediali utilizzati per la fatturazione.
results[0].md5stringMD5 checksum del file multimediale.
results[0].resolutionstring · nullableRisoluzione video, o null per l'uscita audio o l'altezza non disponibile.
results[0].durationnumber · nullableDurata in secondi quando disponibile.
results[0].output_formatstringFormato file di uscita.
results[0].fpsnumber · nullableTasso di telaio quando disponibile.
results[0].video_codecstring · nullableVideo codec quando disponibile.
results[0].audio_codecstring · nullableAudio codec quando disponibile.
results[0].dynamic_rangestring · nullableIntervallo dinamico video quando disponibile.
results[0].metadataobject · optionalMetadati file_url, file_size e md5 quando upload_metadata è true. I metadati byte sono esclusi dalle spese di download.

I campi sopra descritti descrivono la risposta predefinita JSON. Le opzioni di formattazione si applicano al record di consegna, non al file multimediale. formati JSON, testo semplice e Markdown.

Async & ciclo di vita in batch

La sottomissione restituisce una ricevuta, non i risultati. Async crea un lavoro; batch restituisce un lavoro separato in queries[] per ogni domanda accettata. Tracciare e recuperare ogni lavoro in modo indipendente.

Inviare a data.flashdata.dev; leggi lo stato del lavoro e i risultati ottenuti api.flashdata.dev con lo stesso X-API-Key. Gli esempi di base API collegati utilizzano Python e cURL.

  1. 1. Salvare il lavoro IDs

    Inviare un download con Async, o mettere più richieste di download all'interno di un array di query Batch. Ogni voce ha bisogno di params.storage. Salvare ogni lavoro restituito ID.

    Async richiesta e ricevuta · Corpo di richiesta Batch

  2. 2. Controllare lo stato

    GET https://api.flashdata.dev/v2/jobs/{jobId}

    pending / processing: sondaggio con ritardo e rispetto Retry-After quando presente. completed: risultati di ricerca. failed: ispezione job.error.

    Leggi job.status, non lo stato della ricevuta di presentazione.

    Stato di controllo · Python e cURL

    Stato del lavoro API riferimento
  3. 3. Risultati di riduzione

    GET https://api.flashdata.dev/v2/jobs/{jobId}/results

    Dopo il completamento, autenticare il risultato letto, quindi prendere il 302 di archiviazione URL senza la chiave API. Salvare la JSON entro le ore di completamento 24.

    Lo JSON descrive i supporti consegnati al vostro storage. Accedere al file multimediale.

    Risultati di riduzione · Python e cURL · Formati di risposta

    Risultato download API riferimento

L'inquinamento e l'ottenimento dei risultati esistenti non consumano i crediti di query. Un timeout inquinante non cancella il lavoro: mantieni il suo ID invece di presentare il lavoro duplicato fatturabile. Codici di errore e comportamento di riprovazione.

Webhook di completamento

Iscriviti per query

Set Set callback_url al livello superiore di una richiesta asincrona, o dentro ogni query in un lotto, fuori params. Non è richiesta alcuna richiesta di registrazione webhook separata.

Utilizzare un HTTPS URL pubblico sulla porta 443. FlashData POSTs una notifica per ogni lavoro che raggiunge completed o failed; l'evento contiene collegamenti, non il risultato stesso.

Riconoscimento e verifica

Ritorno 2xx dopo aver accettato duramente l'evento. Deduplicato da delivery_id, anche inviato come X-Delivery-Id. I reindirizzamenti non sono seguiti.

Recuperare le consegne non effettuate con backoff esponenziale, fino a 8 tenta totale e al massimo 24 ore dopo il completamento. Continua a inquinare come un fallback.

Le chiamate non sono firmate. Confermare il lavoro ID, lo stato sorgente e terminale attraverso endpoint di stato autenticato prima di elaborare la notifica. La consegna ID è per la deduplica, non la prova di autenticità.

Esempio webhook evento e campi
Notifica di completamento illustrativa
{
  "delivery_id": "completion:job_example0001",
  "id": "job_example0001",
  "source": "youtube_download",
  "status": "completed",
  "links": [
    {
      "rel": "self",
      "href": "https://api.flashdata.dev/v2/jobs/job_example0001",
      "method": "GET"
    },
    {
      "rel": "results",
      "href": "https://api.flashdata.dev/v2/jobs/job_example0001/results",
      "method": "GET"
    }
  ]
}
Campo di applicazioneDesignazione
delivery_idstringIdentificatore di consegna stabile. Deduplicare le notifiche utilizzando questo valore; viene inviato anche nell'intestazione X-Delivery-Id.
idstringLavoro ID.
sourcestringFonte di dati richiesta.
statusstringcompletato o fallito.
linksarrayCollegamenti di stato e di risultato. Le notifiche non includono il contenuto dei risultati o una chiave API.
links[].relstringauto o risultati.
links[].hrefstringGestione assoluta API URL; autenticare con la chiave API.
links[].methodstringGET.

Contratto completo di webhook e restrizioni URL

Trattamento file Bulk

Caricare un video ID per linea e creare il lavoro Bulk con la fonte: youtube_download. Le opzioni condivise si applicano a ogni ID nel file.

Mettere la destinazione di archiviazione richiesta in options.storage e le impostazioni dei media in options. I download di Single-job e Batch utilizzano invece params.storage.

I file multimediali vengono consegnati al cloud storage. Il risultato Bulk completato include un manifesto e parti di risultato che descrivono i download. Salvare il manifesto e le parti all'interno di 24 ore dopo che l'intero lavoro Bulk è completato.

Bulk che elabora API · Python e cURL · richieste Batch JSON

Costruire un flusso di lavoro Bulk per questa sorgente · Pausa, riprendere e recuperare

Download video in blocco — toolkit Python

Destinazione di stoccaggio

Includi params.storage in ogni richiesta di download. Set Set storage_url per il tuo secchio o il nome del contenitore e le credenziali di alimentazione con accesso a scrittura. Mantenere le credenziali di archiviazione sul server.

params.storage · destinazione compatibile S3
{
  "storage_type": "s3_compatible",
  "storage_url": "your-media-bucket",
  "object_prefix": "archive/YYYYMMDD",
  "endpoint_url": "https://your-s3-endpoint.example.com",
  "region": "your-provider-region",
  "access_key": "<storage-access-key>",
  "secret_key": "<storage-secret-key>"
}

object_prefix di default a YYYYMMDD, sostituito con la data di caricamento UTC. Utilizzare una directory fissa o un modello come archive/YYYYMMDD.

s3
Fornire access_key e secret_key con accesso a scrittura. Impostare la regione nella regione AWS del vostro secchio.
s3 esempio
params.storage · s3
{
  "storage_type": "s3",
  "storage_url": "your-media-bucket",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "region": "us-east-1"
}
s3_compatible
Fornitura access_key, secret_key e un pubblico HTTPS endpoint_url. Impostare la regione come richiesto dal vostro fornitore; Cloudflare R2 utilizza auto.
s3_compatible esempio
params.storage · s3_compatible
{
  "storage_type": "s3_compatible",
  "storage_url": "your-media-bucket",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "endpoint_url": "https://YOUR_ACCOUNT_ID.r2.cloudflarestorage.com",
  "region": "auto"
}
azure
Fornire account_name e sas_token, un contenitore SAS con permesso di scrittura (sp include w), sr=c delle risorse, scadenza se, versione sv e firma sig. storage_url è il nome del contenitore. Non inviare endpoint_url, access_key o secret_key.
azure esempio
params.storage · azure
{
  "storage_type": "azure",
  "storage_url": "your-media-container",
  "account_name": "yourstorageaccount",
  "sas_token": "sv=2023-11-03&sr=c&sp=w&se=2099-01-01T00%3A00%3A00Z&sig=YOUR_SAS_SIGNATURE"
}
bos
Alimentazione access_key, secret_key e regione: bj, su o hkg. Il punto finale è derivato dalla regione quando omesso. Utilizzare un nome di secchio senza punti.
bos esempio
params.storage · bos
{
  "storage_type": "bos",
  "storage_url": "your-media-bucket",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "region": "bj"
}
cos
Fornire access_key, secret_key e una regione ap-*, come ap-hongkong. storage_url deve includere il suffisso APPID. Non inviare endpoint_url; è derivato dalla regione.
cos esempio
params.storage · cos
{
  "storage_type": "cos",
  "storage_url": "your-media-bucket-1234567890",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "region": "ap-hongkong"
}
gcs
Fornire service_account con project_id, client_email (un indirizzo .gserviceaccount.com), e PEM private_key dal tuo account di servizio. L'account deve avere accesso al secchio. Non inviare access_key, secret_key, regione o endpoint_url.
gcs esempio
params.storage · gcs
{
  "storage_type": "gcs",
  "storage_url": "your-media-bucket",
  "service_account": {
    "project_id": "your-project-id",
    "client_email": "[email protected]",
    "private_key": "-----BEGIN PRIVATE KEY-----\nYOUR_PRIVATE_KEY\n-----END PRIVATE KEY-----\n"
  }
}
oss
Fornire access_key, secret_key e la regione di secchiello HTTPS endpoint_url.
oss esempio
params.storage · oss
{
  "storage_type": "oss",
  "storage_url": "your-media-bucket",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "endpoint_url": "https://oss-cn-hongkong.aliyuncs.com"
}
tos
Fornire access_key, secret_key e la regione con un cn-, ap-, eu- o noi- prefisso. Il punto finale è derivato dalla regione quando omesso. Utilizzare un nome di secchio senza punti.
tos esempio
params.storage · tos
{
  "storage_type": "tos",
  "storage_url": "your-media-bucket",
  "access_key": "YOUR_ACCESS_KEY",
  "secret_key": "YOUR_SECRET_KEY",
  "region": "cn-beijing"
}

Il risultato è file_url identifica un oggetto nel tuo storage. Gli oggetti privati richiedono l'autorizzazione del fornitore di archiviazione o un URL firmato; la chiave FlashData API non garantisce l'accesso al secchio.

Per un flusso di lavoro completo di presentazione, inquinamento e download, vedere Scarica l'audio YouTube a Amazon S3.

Consegna dei file

Il lavoro è rel: results default endpoint a un reindirizzamento a risultato JSON, non un MP4 download. FlashData carica il supporto effettivo al secchio o al contenitore fornito. La conservazione dei media segue la politica del secchio; il risultato del lavoro JSON scade alle ore 24 dopo il completamento.

results[0].file_url identifica l'oggetto ma non è automaticamente un URL pubblico o firmato. Accedere ai supporti privati con lo storage SDK o generare un URL firmato a breve durata sul proprio server. Non inviare la chiave FlashData API al provider di storage.

Abilita' upload_metadata per caricare un {video_id}_meta.json compagno nello stesso prefisso. La sua posizione e checksum appaiono sotto results[0].metadata.

La modalità di download Browser della console è separata. I download pubblici di API utilizzano il proprio storage; non includono solo la console browser_delivery impostazioni.

Recupero di errore

Per l'upload di guasti o archiviazione 403, controllare il fornitore, secchio, regione, endpoint e oggetti-scrittura autorizzazioni. Un irraggiungibile o privato file_url non significa di per sé che il caricamento non sia riuscito: controlla l'oggetto tramite il tuo provider di storage.

Un video rimosso o non disponibile non può essere recuperato da polling. Per formati non disponibili, ispezionare Formati dei metadati, rilassare i vincoli di qualità o rimuovere il selettore avanzato. Le richieste di solo audio richiedono m4a, mp3 o opus; richieste di video richiedono mp4, webm o mkv.

Se il risultato JSON è scaduto, prima controllare il secchio per i supporti consegnati. Resubmitting crea un nuovo download e può incorrere un'altra carica; non recupera il vecchio risultato JSON.

Per l'autenticazione, l'equilibrio, il formato delle richieste e i guasti dei limiti di velocità, utilizzare il riferimento di errore condiviso. Un timeout di presentazione può ancora aver creato un lavoro; controllare il lavoro esistente prima di riprovare.

Errori e codici di stato · Quando riprova · Limiti di tasso

Guida passo-passo: Scarica un video e verifica la consegna

Prezzi

PianiTassi di utilizzoper GB consegnatoAbbonamentiCrediti inclusi per periodo di fatturazione
A consumo0,10 USDNessun canone mensileRicarica quando serve
Micro0,08 USD49,00 USD / meseCrediti 1000 (50,00 USD dell'utilizzo API) inclusi
Starter0,07 USD199,00 USD / meseCrediti 4000 (200,00 USD dell'utilizzo API) inclusi
Pro0,06 USD499,00 USD / meseCrediti 10.000 (500,00 USD dell'utilizzo API) inclusi
Scale0,05 USD999,00 USD / meseCrediti 20.000 (1000,00 USD dell'utilizzo API) inclusi
Business0,04 USD1999,00 USD / meseCrediti 40.000 (2000,00 USD dell'utilizzo API) inclusi

Un piano per account. Crediti condivisi tra i tre prodotti. L’utilizzo coperto dai crediti inclusi non viene addebitato nuovamente.

I prezzi attuali e i limiti del piano