Obtenir des en-têtes Kasada avec l’API

Utilisez Python 3.10+ ou Node.js 22+ avec le SDK officiel. Installez le SDK depuis les téléchargements officiels.

Définissez SOLVETHREE_API_KEY sur la clé API de votre espace de travail et SOLVETHREE_PROXY sur l’URL de votre proxy. Exécutez ce code sur le serveur pour préserver la confidentialité de la clé API. Modifiez url pour indiquer l’URL HTTPS prévue sur l’hôte pris en charge.

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);

Les deux exemples appellent solve, qui crée une tâche et interroge son état jusqu’à ce qu’elle soit prête ou qu’une erreur soit levée. La section suivante envoie les en-têtes renvoyés à la cible.

La tâche fournit type, url, un seul proxy et un requestId facultatif. N’ajoutez pas de champs d’identité de navigateur personnalisés : utilisez l’identité renvoyée dans la solution.

{
  "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"
  }
}

Copiez l’objet solution.headers en entier. Définissez User-Agent et sec-ch-ua à partir du résultat, et utilisez le même proxy que pour la résolution :

# 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();
}

Ces suites d’exemples nécessitent requests en Python ou undici en Node.js. Elles envoient une requête à l’URL exacte de la tâche et remplacent les en-têtes de navigateur en conflit. Conservez les autres en-têtes d’application ou données de session requis par votre cible.

Si vous utilisez proxyCandidates, sélectionnez le proxy qui a réussi avec successful_proxy ou successfulProxy avant d’envoyer la requête cible. Les exemples à proxy unique réutilisent request["proxy"] en Python ou request.proxy en Node.js.

Vérifiez la réponse de la cible après l’envoi. En cas de statut 403, utilisez le guide de dépannage Ticketmaster pour vérifier quelle requête est rejetée.

solve() gère l’interrogation périodique pour vous. Pour recevoir immédiatement l’ID de tâche, utilisez create_task ou createTask avec un délai d’attente nul, puis récupérez la tâche correspondant à cet ID jusqu’à ce qu’elle atteigne ready ou failed.

Avec l’API directe, la création Kasada attend jusqu’à 75 secondes par défaut. Définissez un délai d’expiration HTTP supérieur à cette attente, ou utilisez ?waitMs=0 et interrogez périodiquement la tâche. Consultez Interrogation des tâches et délais d’expiration pour connaître la séquence de requêtes.

Si une tâche échoue, arrêtez de l’interroger et examinez errorCode et error. Les résolutions échouées sont remboursées. Si la création dépasse le délai d’expiration, conservez le même requestId et les mêmes paramètres pour récupérer la tâche ; un nouvel ID peut créer une autre résolution facturable.