# Code Examples

Complete Python, JavaScript, and cURL examples.

Complete, copy-paste examples with error handling for every API category.

### Text-to-Speech

**Python — TTS Generation**

```
# pip install requests
import requests, time, sys

API_KEY = "YOUR_API_KEY"
BASE    = "https://api.algrow.online"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

# 1. Submit generation
resp = requests.post(f"{BASE}/api/generate-simple", headers=HEADERS, data={
    "script":           "Welcome to our YouTube channel.",
    "voice_id":         "21m00Tcm4TlvDq8ikWAM",
    "provider":         "elevenlabs",
    "stability":        "0.7",
    "similarity_boost": "0.8",
})

data = resp.json()
if not data.get("success"):
    print(f"Error: {data.get('error')}")
    sys.exit(1)

job_id = data["job_id"]
print(f"Job submitted: {job_id}")

# 2. Poll for completion (max 60 attempts = ~3 minutes)
for attempt in range(60):
    status = requests.get(f"{BASE}/api/job-status/{job_id}", headers=HEADERS).json()

    if status["status"] == "completed":
        print(f"Audio ready: {status['audio_url']}")
        break
    elif status["status"] == "failed":
        print(f"Generation failed: {status.get('error', 'Unknown error')}")
        sys.exit(1)
    else:
        print(f"Status: {status['status']}... (attempt {attempt + 1})")
        time.sleep(3)
else:
    print("Timed out waiting for generation")
    sys.exit(1)
```

**JavaScript (Node.js 18+)**

```
const API_KEY = "YOUR_API_KEY";
const BASE    = "https://api.algrow.online";

async function generateTTS(text, voiceId, options = {}) {
  // 1. Submit generation
  const form = new URLSearchParams();
  form.append("script", text);
  form.append("voice_id", voiceId);
  form.append("provider", options.provider || "elevenlabs");
  if (options.stability)        form.append("stability", options.stability);
  if (options.similarity_boost) form.append("similarity_boost", options.similarity_boost);
  if (options.speed)            form.append("speed", options.speed);

  const submitRes = await fetch(`${BASE}/api/generate-simple`, {
    method: "POST",
    headers: { Authorization: `Bearer ${API_KEY}` },
    body: form,
  });

  const submitData = await submitRes.json();
  if (!submitData.success) throw new Error(submitData.error);

  const jobId = submitData.job_id;
  console.log(`Job submitted: ${jobId}`);

  // 2. Poll for completion
  for (let i = 0; i < 60; i++) {
    const statusRes = await fetch(`${BASE}/api/job-status/${jobId}`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });
    const status = await statusRes.json();

    if (status.status === "completed") return status.audio_url;
    if (status.status === "failed") throw new Error(status.error || "Generation failed");

    console.log(`Status: ${status.status}... (attempt ${i + 1})`);
    await new Promise(r => setTimeout(r, 3000));
  }

  throw new Error("Timed out waiting for generation");
}

// Usage
generateTTS("Hello from the Algrow API!", "21m00Tcm4TlvDq8ikWAM", {
  stability: "0.7",
  similarity_boost: "0.8",
})
  .then(url => console.log("Audio:", url))
  .catch(err => console.error("Error:", err.message));
```

**cURL (complete workflow)**

```
# Step 1: Submit generation
RESPONSE=$(curl -s -X POST "https://api.algrow.online/api/generate-simple" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "script=This is a complete cURL example with polling." \
  -F "voice_id=21m00Tcm4TlvDq8ikWAM")

echo "Submit response: $RESPONSE"
JOB_ID=$(echo $RESPONSE | python3 -c "import sys,json; print(json.load(sys.stdin)['job_id'])")

# Step 2: Poll until complete
while true; do
  STATUS=$(curl -s "https://api.algrow.online/api/job-status/$JOB_ID" \
    -H "Authorization: Bearer YOUR_API_KEY")

  STATE=$(echo $STATUS | python3 -c "import sys,json; print(json.load(sys.stdin)['status'])")

  if [ "$STATE" = "completed" ]; then
    AUDIO=$(echo $STATUS | python3 -c "import sys,json; print(json.load(sys.stdin)['audio_url'])")
    echo "Audio ready: $AUDIO"
    break
  elif [ "$STATE" = "failed" ]; then
    echo "Failed: $STATUS"
    break
  fi

  echo "Status: $STATE ..."
  sleep 3
done
```

### YouTube Scraper

**Python — Scrape a Channel**

```
import requests, time

API_KEY = "YOUR_API_KEY"
BASE    = "https://api.algrow.online"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

# 1. Submit scraping job
resp = requests.post(f"{BASE}/api/youtube-scraper", headers=HEADERS, json={
    "url": "https://www.youtube.com/@MrBeast",
    "video_type": "videos",
    "sort": "popular",
    "max_videos": 10,
    "include_comments": true
})

data = resp.json()
job_id = data["job_id"]
print(f"Job {job_id} queued ({data['mode']} mode)")

# 2. Poll for results
for _ in range(120):
    status = requests.get(f"{BASE}/api/youtube-scraper/{job_id}", headers=HEADERS).json()

    if status["status"] == "completed":
        result = status["result"]
        print(f"Got {result['total_videos']} videos, {result['total_views']:,} total views")
        for v in result["videos"]:
            print(f"  {v['title']} — {v['view_count']:,} views")
        break
    elif status["status"] == "failed":
        print(f"Failed: {status.get('error')}")
        break

    time.sleep(3)
```

**cURL — Scrape a Single Video**

```
# Retrieve a single video with comments
curl -X POST "https://api.algrow.online/api/youtube-scraper" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "include_comments": true}'
```

### Terminated Channels

**Python — Search Terminated Channels**

```
import requests

API_KEY = "YOUR_API_KEY"
BASE    = "https://api.algrow.online"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

# Search for terminated gaming channels with 100k+ subs
resp = requests.get(f"{BASE}/api/terminated-channels/search", headers=HEADERS, params={
    "q": "gaming",
    "languages": "English",
    "min_subs": 100000,
    "sort": "subs_desc",
    "per_page": 10
})

data = resp.json()
for ch in data["channels"]:
    print(f"{ch['channel_title']} — {ch['subscriber_count']:,} subs, terminated {ch['terminated_days_ago']}d ago")
    for v in ch.get("recent_videos", []):
        print(f"  └ {v['title']} ({v['view_count']:,} views)")
```

**cURL — Recently Terminated Channels**

```
curl "https://api.algrow.online/api/terminated-channels/search?sort=date_desc&per_page=20" \
-H "Authorization: Bearer YOUR_API_KEY"
```

### Studio

**Python — Generate an Image**

```
import requests, time

API_KEY = "YOUR_API_KEY"
BASE    = "https://api.algrow.online"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

# Submit image generation
resp = requests.post(f"{BASE}/api/generate-image", headers=HEADERS, json={
    "prompt": "a sunset over mountains, photorealistic",
    "model": "nano-banana-2",
    "aspect_ratio": "16:9"
})

job_id = resp.json()["job_id"]

# Poll for result
for _ in range(60):
    status = requests.get(f"{BASE}/api/job-status/{job_id}", headers=HEADERS).json()
    if status["status"] == "completed":
        print(f"Image: {status['result_url']}")
        break
    elif status["status"] == "failed":
        print(f"Failed: {status.get('error')}")
        break
    time.sleep(3)
```

**cURL — Remove Captions from Video**

```
curl -X POST "https://api.algrow.online/api/caption-remover" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"video_url": "https://example.com/my-video.mp4"}'
```

**cURL — Generate a Video**

```
curl -X POST "https://api.algrow.online/api/generate-video" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"prompt": "a cat walking through a field of flowers", "model": "sora-2", "seconds": "4"}'
```