# YouTube Data latihan terbaik

Cari video yang relevan, pilih trek judul dan proses upload kanal baru tanpa mengulang kerja.

Referensi kanonikal: https://flashdata.dev/id/docs/guides/youtube-data-guide
Diulang: 2026-11-04 oleh FlashData

<a id="choose"></a>

## Mulailah dengan informasi yang sudah Anda miliki

Setiap sumber menjawab pertanyaan yang berbeda. Penemuan Skip untuk video yang dikenal ID atau channel handle, dan memperkaya hanya video yang dibutuhkan tugas Anda.

| Tugas Anda | Sumber | Keputusan |
| --- | --- | --- |
| Cari video tentang topik | youtube_search | Mulailah dengan lima kandidat, kemudian pilih dengan relevansinya. |
| Inspeksi video yang dikenal | youtube_metadata | Dapatkan judul, saluran, durasi, dan bahasa judul. |
| Summarize atau cite apa yang dikatakan | youtube_transcript / youtube_captions | Pilih bahasa dan trek otomatis atau manual. |
| Periksa uploads saluran baru-baru ini | youtube_channel | Compare dikembalikan IDs dengan IDs diproses Anda. |

- [Cari video](https://flashdata.dev/id/docs/guides/youtube-data-guide/reference.md#discover)
- [Bekerja dengan video yang dikenal](https://flashdata.dev/id/docs/guides/youtube-data-guide/reference.md#metadata)
- [Monitor kanal](https://flashdata.dev/id/docs/guides/youtube-data-guide/reference.md#channel)

<a id="setup"></a>

## Jalankan contoh permintaan

Simpan setiap tubuh JSON memakai nama berkas yang ditampilkan. Python menggunakan pembantu query.py di bawah ini; cURL dapat mengirimkan berkas yang sama. Gunakan kunci dengan izin sumber yang Anda butuhkan dan kredit yang tersedia. Setiap pengiriman adalah satu permintaan, terlepas dari jumlah video yang dikembalikan.

### Python

Python 3.10+. Pasang permintaan sekali, simpan query.py di bawah ini, kemudian gunakan perintah di samping setiap permintaan. Keluaran yang telah ada dipakai kembali; masukan yang berubah memerlukan sebuah nama berkas keluaran baru.

#### Instal

```bash
python -m pip install requests
```


### cURL

Bash. Ganti REQUEST.json dan RESULT.json dengan nama berkas untuk contoh yang Anda pilih. Periksa hasilnya sebelum mengulangi permintaan; perintah ini menyimpan tubuh HTTP bahkan untuk kesalahan.

#### Ajukan permintaan JSON yang disimpan

```bash
(
set -eu
: "${FLASHDATA_API_KEY:?Set FLASHDATA_API_KEY first}"
test ! -e RESULT.json || { echo 'Read RESULT.json first'; exit 1; }
curl --fail-with-body --silent --show-error --max-time 70 \
  --request POST 'https://data.flashdata.dev/v1/queries/realtime' \
  --header "X-API-Key: $FLASHDATA_API_KEY" \
  --header 'Content-Type: application/json' \
  --data-binary @REQUEST.json --output RESULT.json
)
```



<a id="authenticate"></a>

### Set kunci API Anda

Gunakan FLASHDATA_API_KEY dari terminal atau toko rahasia Anda. Jika tidak masukkan kunci menggunakan satu prompt tersembunyi di bawah ini. Tetap dalam proses menjalankan contoh-contoh ini.

#### Bash

##### Menentukan kunci

```bash
# Bash: paste the key into a hidden prompt, not into this command.
read -r -s -p "FlashData API key: " FLASHDATA_API_KEY
printf '\n'
export FLASHDATA_API_KEY
```


#### PowerShell 7

##### Menentukan kunci

```powershell
# PowerShell 7: paste the key into a hidden prompt.
$flashdataSecureKey = Read-Host "FlashData API key" -AsSecureString
$env:FLASHDATA_API_KEY = [System.Net.NetworkCredential]::new("", $flashdataSecureKey).Password
Remove-Variable flashdataSecureKey
```


- [Tombol API](https://flashdata.dev/app/api-keys)
- [Uji coba agen dan penautan akun](https://flashdata.dev/id/docs/guides/agent-onboarding/reference.md)

<a id="runner"></a>

### Simpan query.py untuk Python contoh

Buat query.py dalam folder kerja baru dan salin kode lengkap di bawahnya. Simpan permintaan berkas JSON dan skrip Python lainnya dalam folder ini, dan jalankan semua perintah dari sana.

#### query.py

```python
# query.py — submit a saved request once, then reuse its response.
import json
import os
import sys
from pathlib import Path
import requests

if len(sys.argv) != 3:
    raise SystemExit("Usage: python query.py REQUEST.json RESULT.json")
payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8-sig"))
output = Path(sys.argv[2])
marker = output.with_name(output.name + ".request.json")
receipt = output.with_name(output.name + ".http.json")
if marker.exists():
    if json.loads(marker.read_text()) != payload:
        raise SystemExit("Changed request: choose a new output filename.")
    if not output.exists() or not receipt.exists():
        raise SystemExit("Outcome unknown: check History before resubmitting.")
    saved = json.loads(receipt.read_text())
    if saved["status"] != 200 or json.loads(output.read_text(encoding="utf-8")).get("status") != "done":
        raise SystemExit(f"Saved request failed or incomplete; Retry-After: {saved['retry_after']}. Inspect {output}.")
    print(f"Read the saved {output}; no new query submitted.")
    raise SystemExit(0)
if output.exists():
    raise SystemExit("Output already exists. Read it or choose a new filename.")
key = os.environ["FLASHDATA_API_KEY"]
with marker.open("x", encoding="utf-8") as file:
    json.dump(payload, file)
response = requests.post("https://data.flashdata.dev/v1/queries/realtime",
                         headers={"X-API-Key": key}, json=payload,
                         timeout=70, allow_redirects=False)
output.write_text(response.text, encoding="utf-8")
receipt.write_text(json.dumps({"status": response.status_code,
                               "retry_after": response.headers.get("Retry-After")}), encoding="utf-8")
if response.status_code != 200:
    raise SystemExit(f"HTTP {response.status_code}; Retry-After: {response.headers.get('Retry-After')}")
if response.json().get("status") != "done":
    raise SystemExit(f"Inspect {output} and History before retrying.")
print(json.dumps({"saved": str(output), "usage": response.json().get("usage")}, indent=2))
```


<a id="discover"></a>

## Cari kandidat sebelum mengambil rincian

Filter video tidak termasuk tipe hasil lain; subtitle narrows penemuan ke video dengan takarir. Ini tidak memilih bahasa judul atau menjamin trek yang Anda butuhkan. Simpan sebagai discover-request.json.

### discover-request.json

```json
{
  "source": "youtube_search",
  "query": "battery recycling process explained",
  "params": {
    "max_results": 5,
    "filters": {
      "type": "video",
      "subtitles": true
    }
  }
}
```

### Kirim sekali dengan query.py

```bash
python query.py discover-request.json search.json
```


<a id="candidates"></a>

### Pilih dengan relevansi, bukan ID pertama

Simpan candidates.py di samping query.py dan search.json, kemudian jalankan dari folder itu. Ini menjaga urutan pencarian dan menghapus duplikat video IDs. Inspeksi judul, saluran, dan durasi, lalu salin ID terpilih ke dalam permintaan berikutnya. Daftar kosong adalah pencarian selesai tanpa kandidat.

#### candidates.py

```python
# candidates.py — read a saved response; no API calls.
import json
import re
from pathlib import Path

data = json.loads(Path("search.json").read_text(encoding="utf-8"))
if data.get("status") != "done":
    raise SystemExit("Search did not complete; inspect search.json.")
candidates, seen = [], set()
for item in (data.get("results") or [{}])[0].get("results", []):
    video_id = item.get("videoId", "")
    if not re.fullmatch(r"[A-Za-z0-9_-]{11}", video_id) or video_id in seen:
        continue
    seen.add(video_id)
    candidates.append({"videoId": video_id, "title": item.get("title"),
                       "channel": item.get("channel"), "duration": item.get("duration"),
                       "url": "https://www.youtube.com/watch?v=" + video_id})
Path("candidates.json").write_text(json.dumps(candidates, indent=2), encoding="utf-8")
print(json.dumps(candidates, indent=2))
```

#### Baca pencarian yang disimpan

```bash
python candidates.py
```


<a id="extended"></a>

### Ekspansi hanya ketika daftar pendek tidak cukup

Pencarian Standar mendukung max_results hingga 20. Untuk koleksi yang lebih luas, beralih ke youtube_search_extended, yang mendukung hingga 700 dan memiliki harga terpisah. Contoh ini menanyakan 50; periksa apakah hasil pertama Anda berguna sebelum memperkaya mereka semua.

#### extended-request.json

```json
{
  "source": "youtube_search_extended",
  "query": "battery recycling process explained",
  "params": {
    "max_results": 50,
    "filters": {
      "type": "video"
    }
  }
}
```

#### Lari sekali

```bash
python query.py extended-request.json extended.json
```

- [Kirim pencarian secara asinkron lebih lama](https://flashdata.dev/id/docs/reference/realtime-and-async/reference.md#async)
- [Enrich dipilih IDs](https://flashdata.dev/id/docs/guides/enrich-youtube-videos/reference.md)

<a id="metadata"></a>

## Ambil hanya metadata yang diperlukan fitur Anda

Ganti sampel video_id dengan ID yang Anda pilih. Pertahankan format dan bab dinonaktifkan untuk kartu video sederhana atau pemeriksaan bahasa. Aktifkan include_chapters untuk suatu garis besar, atau include_formats ketika memilih sebuah format media.

### metadata-request.json

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

### Kirim sekali dengan query.py

```bash
python query.py metadata-request.json metadata.json
```

- [Ruas respon metadata](https://flashdata.dev/id/docs/sources/youtube_metadata/reference.md#response)
- [Keran pengiriman media](https://flashdata.dev/id/docs/guides/media-delivery-pipeline/reference.md)

<a id="tracks"></a>

### Inspeksi bahasa yang tersedia

Hasil baca [0] .transcriptLanguages sebelum memilih takarir. Format, bab, dan bahasa adalah bidang pada objek video yang dikembalikan; catatan penggunaan milik dari respon luar.

| Tatanan | Gunakan untuk |
| --- | --- |
| language | Sebuah kode dari transcriptLanguages, seperti en atau Zh-Hans. Daftar ini tidak membedakan trek manual dan otomatis. |
| auto: true | Trek yang dihasilkan secara otomatis. |
| auto: false | Trek yang tersedia secara manual. Tidak ada fallback antara dua jenis trek. |

#### Baca permintaan metadata.json

```bash
python -m json.tool metadata.json
```


<a id="captions"></a>

## Pilih bahasa dan trek secara eksplisit

Gunakan yang sama video_id sebagai permintaan metadata Anda dan mengubah bahasa dan auto untuk mencocokkan trek yang dipilih. youtube_transcript default ke auto: true; youtube_captions default ke auto: false. Keduanya mengambil keterangan yang sudah ada, bukan teks speech-to-.

### captions-request.json

```json
{
  "source": "youtube_transcript",
  "video_id": "FUfGcZ092b0",
  "params": {
    "language": "en",
    "auto": true
  }
}
```

### Kirim sekali dengan query.py

```bash
python query.py captions-request.json captions.json
```

- [Parameter judul](https://flashdata.dev/id/docs/sources/youtube_transcript/reference.md#parameters)
- [Buat ringkasan lengkap](https://flashdata.dev/id/docs/guides/youtube-summary/reference.md)

<a id="citations"></a>

### Jauhkan penanda waktu dengan bukti

Simpan cite-segments.py di samping captions.json dan menjalankannya dari folder itu. Gunakan hasil [0] .segmen untuk kutipan: awal dan akhir adalah detik. Pertahankan languageCode dan isAutoGenerated dengan teks. fullText berguna untuk dibaca, tetapi tidak menggantikan segmen waktu. Bila trek yang dipilih hilang, rekam jeda sebelum menentukan apakah kuiri lain bernilai.

#### cite-segments.py

```python
import json
from pathlib import Path

response = json.loads(Path("captions.json").read_text(encoding="utf-8"))
if response.get("status") != "done":
    raise SystemExit("Inspect captions.json before continuing.")
track = (response.get("results") or [{}])[0]
if not track.get("segments"):
    raise SystemExit("No caption evidence was returned.")
for segment in track["segments"][:3]:
    url = f"https://www.youtube.com/watch?v={track['videoId']}&t={int(segment['start'])}s"
    print(segment["text"], url)
```

#### Baca takarir yang disimpan API panggilan

```bash
python cite-segments.py
```


<a id="channel"></a>

## Proses hanya video baru dari kanal yang dikenal

Gunakan sebuah saluran handle dan sebuah bounded video_limit (1–100). hasil [0] .videos adalah daftar yang dikembalikan; videoCount adalah metadata saluran, bukan jumlah butir yang dikembalikan. Pilih batas dan jadwal yang mencakup upload yang perlu Anda amati.

### channel-request.json

```json
{
  "source": "youtube_channel",
  "handle": "@TED",
  "params": {
    "video_limit": 10
  }
}
```

### Kirim sekali dengan query.py

```bash
python query.py channel-request.json channel.json
```


<a id="channel-diff"></a>

### Pertahankan antrian dan pemeriksaan pelengkapan

Simpan channel-queue.py di samping query.py dan channel.json, dan jalankan dari folder itu. Jalankan tanpa argumen untuk membuat new-ids.json, kemudian proses dan menyimpan bukti bagi mereka IDs. Jalankan --commit hanya setelah setiap antrian ID sukses; kegagalan meninggalkan pos pemeriksaan tidak berubah. Gunakan satu direktori per saluran dan satu pekerja untuk contoh ini.

#### channel-queue.py

```python
# channel-queue.py — plan first; commit only after every queued video is processed.
import json
import re
import sys
from pathlib import Path

checkpoint = Path("processed-ids.json")
processed = set(json.loads(checkpoint.read_text()) if checkpoint.exists() else [])
queue = Path("new-ids.json")
if sys.argv[1:] == ["--commit"]:
    processed.update(json.loads(queue.read_text()))
    temporary = checkpoint.with_suffix(".tmp")
    temporary.write_text(json.dumps(sorted(processed)), encoding="utf-8")
    temporary.replace(checkpoint)
    queue.unlink()
    print("Checkpoint saved.")
elif sys.argv[1:]:
    raise SystemExit("Usage: python channel-queue.py [--commit]")
else:
    data = json.loads(Path("channel.json").read_text(encoding="utf-8"))
    if data.get("status") != "done":
        raise SystemExit("Channel query did not complete.")
    ids = dict.fromkeys(video.get("videoId", "") for video in
                        (data.get("results") or [{}])[0].get("videos", []))
    new = [value for value in ids if re.fullmatch(r"[A-Za-z0-9_-]{11}", value)
           and value not in processed]
    if queue.exists() and json.loads(queue.read_text()) != new:
        raise SystemExit("Finish the existing queue before replacing it.")
    queue.write_text(json.dumps(new, indent=2), encoding="utf-8")
    print(json.dumps(new, indent=2))
```

#### Rencana proses 1f comit

```bash
python channel-queue.py
# Process every ID in new-ids.json and save its result first.
python channel-queue.py --commit
```

- [Jadwal dan penggunaan ulang kredensial](https://flashdata.dev/id/docs/guides/recurring-tasks/reference.md)
- [Kembangkan daftar video](https://flashdata.dev/id/docs/guides/enrich-youtube-videos/reference.md)

<a id="channel-checkpoint"></a>

### Mulai pemeriksaan kanal baru dengan sengaja

Query helper menggunakan kembali respon yang disimpan. Untuk pemeriksaan dijadwalkan berikutnya, gunakan nama berkas hasil baru, periksa, lalu salin bahwa respon selesai ke channel.json untuk langkah antrian. Simpan processed-ids.json antara berjalan. Daftar baru-baru ini bukan ekspor saluran penuh atau arus peristiwa.

#### Cek berikutnya: pilih nama berkas baru

```bash
python query.py channel-request.json channel-next.json
```

#### Setelah mengkonfirmasi status dilakukan

```bash
python -c "from shutil import copyfile; copyfile('channel-next.json', 'channel.json')"
```


<a id="suggestions"></a>

## Gunakan saran untuk meningkatkan permintaan

Saran kembali frasa dalam hasil [0], bukan rekaman video. Pilih frasa yang berguna dan buat permintaan youtube_search terpisah. Mengatur bahasa dan wilayah untuk penonton yang sedang Anda teliti.

### suggestions-request.json

```json
{
  "source": "youtube_suggestions",
  "query": "battery recycling",
  "params": {
    "language": "en",
    "region": "US"
  }
}
```

### Kirim sekali dengan query.py

```bash
python query.py suggestions-request.json suggestions.json
```


<a id="license"></a>

## Simpan label lisensi tanpa memperlakukan mereka sebagai izin

youtube_trainability mengembalikan sebuah label lisensi untuk sebuah video. Diijinkan: ["all"] memetakan ke Creative Commons; ["none"] juga mencakup metadata lisensi hilang. Jauhkan video ID, sumber respon dan tanggal pengambilan. Label ini tidak memberikan pengunduhan, penggunaan ulang atau hak pelatihan.

### license-request.json

```json
{
  "source": "youtube_trainability",
  "video_id": "FUfGcZ092b0"
}
```

### Kirim sekali dengan query.py

```bash
python query.py license-request.json license.json
```


<a id="operations"></a>

## Terikat pekerjaan untuk aplikasi dan agen

| Aturan | Implementasi |
| --- | --- |
| Pilih sebelum memperkaya | Untuk tugas topik: satu pencarian, satu metadata video terpilih dan satu jalur judul yang dipilih. Memaksakan anggaran panggilan dalam aplikasi Anda, dan harga masing-masing sumber terpisah. |
| Menggunakan ulang oleh masukan yang sebenarnya | Metadata: pilihan video ID +. Captions: video ID + bahasa + track. Rekaman saluran juga perlu waktu pengambilan atau menjalankan ID. |
| Berhenti pada bukti hilang | Jangan coba lagi hasil penemuan kosong atau trek terjemahan switch diam-diam. Kembalikan jeda sehingga pengguna atau alur kerja dapat memilih aksi berikutnya. |
| Jaga penggunaan dan pekerjaan gagal | Simpan penggunaan dengan respon sukses. Pada 429, kehormatan Retry-After; setelah pengajuan yang tidak pasti, periksa History sebelum kueri dibayar lain. |

- [Realtime dan async](https://flashdata.dev/id/docs/reference/realtime-and-async/reference.md)
- [Batch dan massal](https://flashdata.dev/id/docs/reference/batch-and-bulk/reference.md)
- [Galat dan coba-coba](https://flashdata.dev/id/docs/errors/reference.md#retries)
- [Harga dan keseimbangan saat ini](https://flashdata.dev/id/docs/guides/credits-and-billing/reference.md)
