Obtén cabeceras de Kasada con la API

Usa Python 3.10+ o Node.js 22+ con el SDK oficial. Instala el SDK desde las descargas oficiales.

Establece SOLVETHREE_API_KEY con la clave de API de tu espacio de trabajo y SOLVETHREE_PROXY con la URL de tu proxy. Ejecútalo en el servidor para mantener privada la clave de API. Cambia url por la URL HTTPS prevista del host compatible.

import os
from uuid import uuid4
from solvethree import Solvethree

client = Solvethree(os.environ["SOLVETHREE_API_KEY"])
request = {
    'type': 'KasadaTask',
    'url': 'https://www.ticketmaster.com/',
    "proxy": os.environ["SOLVETHREE_PROXY"],
    "requestId": str(uuid4()),
}
result = client.solve(request, timeout=180)
headers = result["solution"]["headers"]
print("Ready task:", result["id"])

import { randomUUID } from 'node:crypto';
import { Solvethree } from '@solvethree/sdk';

const client = new Solvethree({ apiKey: process.env.SOLVETHREE_API_KEY });
const request = {
  type: 'KasadaTask',
  url: 'https://www.ticketmaster.com/',
  proxy: process.env.SOLVETHREE_PROXY,
  requestId: randomUUID(),
};
const result = await client.solve(request, { timeoutMs: 180_000 });
const headers = result.solution.headers;
console.log('Ready task:', result.id);

Ambos ejemplos llaman a solve, que crea una tarea y consulta su estado hasta que esté lista o se produzca un error. La siguiente sección envía las cabeceras devueltas al destino.

La tarea proporciona type, url, un único proxy y un requestId opcional. No añadas campos de identidad de navegador personalizados: usa la identidad devuelta en la solución.

{
  "id": "example-kasada",
  "status": "ready",
  "solution": {
    "headers": {
      "x-kpsdk-ct": "EXAMPLE_HEADER_VALUE",
      "x-kpsdk-cd": "EXAMPLE_HEADER_VALUE"
    },
    "userAgent": "EXAMPLE_USER_AGENT",
    "secChUa": "EXAMPLE_CLIENT_HINTS"
  }
}

Copia el objeto solution.headers completo. Establece User-Agent y sec-ch-ua a partir del resultado y usa el mismo proxy que en la resolución:

# Continue after the Kasada solve. Install requests separately: pip install requests.
import requests

solution = result["solution"]
headers = {name: value for name, value in solution["headers"].items()
           if name.lower() not in {"user-agent", "sec-ch-ua"}}
headers.update({"User-Agent": solution["userAgent"], "sec-ch-ua": solution["secChUa"]})
response = requests.get(
    request["url"], headers=headers,
    proxies={"http": request["proxy"], "https": request["proxy"]},
    timeout=30, allow_redirects=False,
)
print("Target HTTP status:", response.status_code)

// Continue after the Kasada solve. Install undici separately: npm install undici@7.
import { fetch, ProxyAgent } from 'undici';

const targetHeaders = new Headers(result.solution.headers);
targetHeaders.set('user-agent', result.solution.userAgent);
targetHeaders.set('sec-ch-ua', result.solution.secChUa);
const dispatcher = new ProxyAgent(request.proxy);
try {
  const response = await fetch(request.url, {
    dispatcher, headers: targetHeaders, redirect: 'manual',
    signal: AbortSignal.timeout(30_000),
  });
  console.log('Target HTTP status:', response.status);
  await response.arrayBuffer();
} finally {
  await dispatcher.close();
}

Estas continuaciones requieren requests en Python o undici en Node.js. Envían la URL exacta de la tarea y sustituyen las cabeceras de navegador que entren en conflicto. Conserva las demás cabeceras de aplicación o los datos de sesión que necesite tu destino.

Si usas proxyCandidates, selecciona el proxy que funcionó mediante successful_proxy o successfulProxy antes de enviar la solicitud al destino. Los ejemplos con un solo proxy reutilizan request["proxy"] en Python o request.proxy en Node.js.

Comprueba la respuesta del destino después del envío. Si recibes un 403, usa la guía de solución de problemas de Ticketmaster para comprobar qué solicitud se está rechazando.

solve() se encarga de las consultas periódicas. Para recibir el ID de la tarea de inmediato, usa create_task o createTask con una espera de cero y consulta después ese ID hasta que alcance ready o failed.

Con la API directa, la creación de Kasada espera hasta 75 segundos de forma predeterminada. Establece un tiempo de espera HTTP superior a esa espera, o usa ?waitMs=0 y realiza consultas periódicas. Consulta la secuencia de solicitudes en consultas periódicas de tareas y tiempos de espera.

Si una tarea falla, deja de consultar su estado y revisa errorCode y error. Las resoluciones fallidas se reembolsan. Si se agota el tiempo de espera de la creación, conserva el mismo requestId y los mismos datos de entrada al recuperarla; un ID nuevo puede crear otra resolución facturable.