Descargar tu primer video

import requests

API_KEY   = "YOUR_API_KEY"
VIDEO_URL = "https://www.youtube.com/watch?v=dQw4w9WgXcQ"

response = requests.get(
    "https://api.huntapi.com/v1/video/download",
    headers={"x-api-key": API_KEY},
    params={"url": VIDEO_URL, "quality": "best"},
)
data   = response.json()
job_id = data["job_id"]
print(f"Trabajo enviado: {job_id}")

const API_KEY   = "YOUR_API_KEY";
const VIDEO_URL = "https://www.youtube.com/watch?v=dQw4w9WgXcQ";

const params   = new URLSearchParams({ url: VIDEO_URL, quality: "best" });
const response = await fetch(`https://api.huntapi.com/v1/video/download?${params}`, {
  headers: { "x-api-key": API_KEY },
});
const data  = await response.json();
const jobId = data.job_id;
console.log(`Trabajo enviado: ${jobId}`);

<?php
$apiKey   = "YOUR_API_KEY";
$videoUrl = "https://www.youtube.com/watch?v=dQw4w9WgXcQ";

$params = http_build_query(["url" => $videoUrl, "quality" => "best"]);
$ch     = curl_init("https://api.huntapi.com/v1/video/download?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
$data  = json_decode(curl_exec($ch), true);
curl_close($ch);
$jobId = $data["job_id"];
echo "Trabajo enviado: {$jobId}\n";

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
)

const APIKey   = "YOUR_API_KEY"
const VideoURL = "https://www.youtube.com/watch?v=dQw4w9WgXcQ"

func main() {
    params := url.Values{"url": {VideoURL}, "quality": {"best"}}
    req, _ := http.NewRequest("GET", "https://api.huntapi.com/v1/video/download?"+params.Encode(), nil)
    req.Header.Set("x-api-key", APIKey)

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)

    var data map[string]any
    json.Unmarshal(body, &data)
    jobID := data["job_id"].(string)
    fmt.Println("Trabajo enviado:", jobID)
}

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import org.json.*;

var apiKey   = "YOUR_API_KEY";
var videoUrl = URLEncoder.encode("https://www.youtube.com/watch?v=dQw4w9WgXcQ", StandardCharsets.UTF_8);
var url      = "https://api.huntapi.com/v1/video/download?url=" + videoUrl + "&quality=best";

var client  = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder().uri(URI.create(url))
    .header("x-api-key", apiKey).GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
var jobId    = new JSONObject(response.body()).getString("job_id");
System.out.println("Trabajo enviado: " + jobId);

using System.Net.Http;
using System.Text.Json;

var apiKey   = "YOUR_API_KEY";
var videoUrl = Uri.EscapeDataString("https://www.youtube.com/watch?v=dQw4w9WgXcQ");

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", apiKey);

var body  = await client.GetStringAsync($"https://api.huntapi.com/v1/video/download?url={videoUrl}&quality=best");
var jobId = JsonDocument.Parse(body).RootElement.GetProperty("job_id").GetString()!;
Console.WriteLine($"Trabajo enviado: {jobId}");

use reqwest::Client;
use serde_json::Value;

let client    = Client::new();
let api_key   = "YOUR_API_KEY";
let video_url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ";

let data = client.get("https://api.huntapi.com/v1/video/download")
    .header("x-api-key", api_key)
    .query(&[("url", video_url), ("quality", "best")])
    .send().await?.json::<Value>().await?;

let job_id = data["job_id"].as_str().unwrap();
println!("Trabajo enviado: {}", job_id);

import time

def wait_for_job(job_id: str, poll_interval: int = 5, timeout: int = 300) -> dict:
    start = time.time()
    while time.time() - start < timeout:
        r      = requests.get(f"https://api.huntapi.com/v1/job/{job_id}",
            headers={"x-api-key": API_KEY})
        result = r.json()
        status = result.get("status")
        print(f"  Estado: {status}")

        if status == "done":  return result
        if status == "error": raise RuntimeError(f"Trabajo fallido: {result.get('error')}")
        time.sleep(poll_interval)

    raise TimeoutError("El trabajo no completó dentro del tiempo límite.")

result       = wait_for_job(job_id)
download_url = result["download_url"]
print(f"¡Listo! URL de descarga: {download_url}")

async function waitForJob(jobId: string, pollMs = 5000, timeoutMs = 300_000) {
  const deadline = Date.now() + timeoutMs;

  while (Date.now() < deadline) {
    const res    = await fetch(`https://api.huntapi.com/v1/job/${jobId}`, {
      headers: { "x-api-key": API_KEY },
    });
    const result = await res.json();
    console.log(`  Estado: ${result.status}`);

    if (result.status === "done")  return result;
    if (result.status === "error") throw new Error(`Trabajo fallido: ${result.error}`);
    await new Promise(r => setTimeout(r, pollMs));
  }
  throw new Error("Tiempo límite alcanzado");
}

const result      = await waitForJob(jobId);
const downloadUrl = result.download_url;
console.log(`¡Listo! URL de descarga: ${downloadUrl}`);

function waitForJob(string $apiKey, string $jobId, int $pollSec = 5, int $timeoutSec = 300): array {
    $start = time();
    while (time() - $start < $timeoutSec) {
        $ch = curl_init("https://api.huntapi.com/v1/job/{$jobId}");
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
        $result = json_decode(curl_exec($ch), true);
        curl_close($ch);

        $status = $result["status"] ?? "";
        echo "  Estado: {$status}\n";
        if ($status === "done")  return $result;
        if ($status === "error") throw new RuntimeException("Trabajo fallido: " . ($result["error"] ?? ""));
        sleep($pollSec);
    }
    throw new RuntimeException("Tiempo límite alcanzado");
}

$result      = waitForJob($apiKey, $jobId);
$downloadUrl = $result["download_url"];
echo "¡Listo! URL de descarga: {$downloadUrl}\n";

import "time"

func waitForJob(apiKey, jobID string) (map[string]any, error) {
    deadline := time.Now().Add(5 * time.Minute)
    for time.Now().Before(deadline) {
        req, _ := http.NewRequest("GET", "https://api.huntapi.com/v1/job/"+jobID, nil)
        req.Header.Set("x-api-key", apiKey)
        resp, _ := http.DefaultClient.Do(req)
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()

        var result map[string]any
        json.Unmarshal(body, &result)
        status := result["status"].(string)
        fmt.Println("  Estado:", status)

        if status == "done"  { return result, nil }
        if status == "error" { return nil, fmt.Errorf("trabajo fallido: %v", result["error"]) }
        time.Sleep(5 * time.Second)
    }
    return nil, fmt.Errorf("tiempo límite alcanzado")
}

result, err := waitForJob(APIKey, jobID)
if err != nil { panic(err) }
downloadURL := result["download_url"].(string)
fmt.Println("¡Listo! URL de descarga:", downloadURL)

import java.time.*;

static JSONObject waitForJob(HttpClient client, String apiKey, String jobId) throws Exception {
    var deadline = Instant.now().plusSeconds(300);
    while (Instant.now().isBefore(deadline)) {
        var req  = HttpRequest.newBuilder()
            .uri(URI.create("https://api.huntapi.com/v1/job/" + jobId))
            .header("x-api-key", apiKey).GET().build();
        var resp   = client.send(req, HttpResponse.BodyHandlers.ofString());
        var result = new JSONObject(resp.body());
        var status = result.getString("status");
        System.out.println("  Estado: " + status);

        if ("done".equals(status))  return result;
        if ("error".equals(status)) throw new RuntimeException("Trabajo fallido: " + result.optString("error"));
        Thread.sleep(5000);
    }
    throw new RuntimeException("Tiempo límite alcanzado");
}

var result      = waitForJob(client, apiKey, jobId);
var downloadUrl = result.getString("download_url");
System.out.println("¡Listo! URL de descarga: " + downloadUrl);

async Task<JsonElement> WaitForJob(HttpClient client, string jobId)
{
    var deadline = DateTime.UtcNow.AddMinutes(5);
    while (DateTime.UtcNow < deadline)
    {
        var body   = await client.GetStringAsync($"https://api.huntapi.com/v1/job/{jobId}");
        var result = JsonDocument.Parse(body).RootElement;
        var status = result.GetProperty("status").GetString();
        Console.WriteLine($"  Estado: {status}");

        if (status == "done")  return result;
        if (status == "error") throw new Exception($"Trabajo fallido: {result.GetProperty("error")}");
        await Task.Delay(5000);
    }
    throw new TimeoutException("Tiempo límite alcanzado.");
}

var result      = await WaitForJob(client, jobId);
var downloadUrl = result.GetProperty("download_url").GetString()!;
Console.WriteLine($"¡Listo! URL de descarga: {downloadUrl}");

use tokio::time::{sleep, Duration};
use std::time::Instant;

async fn wait_for_job(client: &Client, api_key: &str, job_id: &str) -> Value {
    let deadline = Instant::now() + Duration::from_secs(300);
    loop {
        assert!(Instant::now() < deadline, "Tiempo límite alcanzado");
        let result = client.get(format!("https://api.huntapi.com/v1/job/{}", job_id))
            .header("x-api-key", api_key)
            .send().await.unwrap().json::<Value>().await.unwrap();
        let status = result["status"].as_str().unwrap_or("");
        println!("  Estado: {}", status);
        if status == "done"  { return result; }
        if status == "error" { panic!("Trabajo fallido: {}", result["error"]); }
        sleep(Duration::from_secs(5)).await;
    }
}

let result       = wait_for_job(&client, api_key, job_id).await;
let download_url = result["download_url"].as_str().unwrap();
println!("¡Listo! URL de descarga: {}", download_url);

filename = "video.mp4"

with requests.get(download_url, stream=True) as r:
    r.raise_for_status()
    with open(filename, "wb") as f:
        for chunk in r.iter_content(chunk_size=8192):
            f.write(chunk)

print(f"Guardado en {filename}")

import { createWriteStream } from "fs";
import { Readable } from "stream";

const fileResponse = await fetch(downloadUrl);
const writer       = createWriteStream("video.mp4");
Readable.fromWeb(fileResponse.body as any).pipe(writer);
await new Promise((resolve, reject) => { writer.on("finish", resolve); writer.on("error", reject); });
console.log("Guardado en video.mp4");

$fp = fopen("video.mp4", "wb");
$ch = curl_init($downloadUrl);
curl_setopt($ch, CURLOPT_FILE, $fp);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
curl_exec($ch);
curl_close($ch);
fclose($fp);
echo "Guardado en video.mp4\n";

resp, _ := http.Get(downloadURL)
defer resp.Body.Close()
file, _ := os.Create("video.mp4")
defer file.Close()
io.Copy(file, resp.Body)
fmt.Println("Guardado en video.mp4")

import java.net.URL;
import java.nio.file.*;

Files.copy(new URL(downloadUrl).openStream(), Path.of("video.mp4"), StandardCopyOption.REPLACE_EXISTING);
System.out.println("Guardado en video.mp4");

using var fileStream = File.Create("video.mp4");
using var download   = await new HttpClient().GetStreamAsync(downloadUrl);
await download.CopyToAsync(fileStream);
Console.WriteLine("Guardado en video.mp4");

use std::io::Write;
use std::fs::File;

let bytes    = reqwest::get(download_url).await?.bytes().await?;
let mut file = File::create("video.mp4").unwrap();
file.write_all(&bytes).unwrap();
println!("Guardado en video.mp4");