Requêtes HTTP par lots
Confiez une liste d'au plus 100 appels web, chacun avec son adresse, sa méthode, ses lignes d'en-tête et son corps : ils s'exécutent en parallèle avec leurs propres nouvelles tentatives. Tous les résultats reviennent ensemble en une seule livraison. Vous payez à l'usage, sans abonnement.
Vous décrivez chaque appel — méthode, URL, en-têtes, corps — et vous récupérez les réponses regroupées, avec le statut et le contenu de chacune.
Pourquoi sortir de votre application une boucle d'appels externes
Presque chaque application contient quelque part une boucle qui appelle des services externes des centaines de fois d'affilée : vérifier qu'une liste d'adresses répond, récupérer les prix de nombreux fournisseurs ou envoyer des avis à une liste d'abonnés. Exécutée dans le même processus que celui qui sert vos utilisateurs, cette boucle leur dispute les connexions et le temps de calcul, et un seul service lent peut bloquer toute la série. Confier la liste sous forme de lot sort cette boucle de votre application.
Comment un lot s'exécute et revient
Vous envoyez une liste d'au plus 100 appels, chacun avec son adresse et, si besoin, sa méthode, ses lignes d'en-tête et son corps, et vous recevez aussitôt une référence de tâche. Les appels s'exécutent en même temps en arrière-plan, chacun avec ses propres nouvelles tentatives. Quand tous sont terminés, réussis, échoués ou à court de tentatives, les résultats arrivent ensemble. Un moteur de prix peut ainsi rafraîchir une douzaine de fournisseurs d'un coup, et un tableau de bord d'exploitation vérifier des dizaines de services externes au même endroit.
Ce que vous réglez pour chaque appel
Vous pouvez ainsi mélanger dans un même lot des appels très différents, ou répéter le même appel avec des données qui varient, selon ce que vous cherchez à accomplir. Rien ne vous oblige à uniformiser : chaque ligne du lot est autonome et se configure à part.
Cas d’usage
Contrôler une liste d’URL
Avant une mise en ligne, Sophie vérifie que trente adresses répondent bien, et repère d’un coup les deux qui renvoient une erreur.
Questions fréquentes
Combien de requêtes puis-je envoyer dans un lot ?
Un lot regroupe une série d’appels raisonnable pour une manipulation ponctuelle. Pour un très gros volume, découpez en plusieurs lots ; chaque requête reste facturée à l’unité, ce qui rend le coût prévisible.
Les appels sont-ils exécutés en parallèle ou en série ?
L’outil enchaîne les appels et vous rend les réponses regroupées. Si l’ordre compte — par exemple créer une ressource avant de la modifier — organisez votre lot en conséquence.
Que se passe-t-il si un appel échoue ?
Les autres appels ne sont pas perdus : chaque requête a son propre résultat, avec son code de statut. Vous repérez celui qui a échoué, son message d’erreur, et vous le rejouez seul si besoin.
Est-ce gratuit ?
Le tarif est affiché, sans abonnement, et vous ne réglez que les appels exécutés.
Faut-il créer un compte ?
Il n'y a pas d'offre gratuite — les paliers gratuits sont détournés et ralentissent tout le monde. Pas d'abonnement, pas de jetons, pas de crédits inventés, et une tâche en échec n'est jamais facturée.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Un POST authentifié crée la tâche ; le résultat arrive par webhook ou par un lien signé. Cette capacité est disponible par API, pas comme outil web interactif.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/dev/http-batch \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"requests":[{"url":"https://api.example.com/a","method":"GET"}]}'const res = await fetch("https://api.kit.forhosting.com/dev/http-batch", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"requests": [
{
"url": "https://api.example.com/a",
"method": "GET"
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/http-batch",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"requests": [
{
"url": "https://api.example.com/a",
"method": "GET"
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/http-batch", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"requests":[{"url":"https://api.example.com/a","method":"GET"}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"requests":[{"url":"https://api.example.com/a","method":"GET"}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/http-batch", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"requests": [
{
"url": "https://api.example.com/a",
"method": "GET"
}
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.http_batch",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Cet outil exécute une liste de requêtes HTTP en une seule opération. C’est utile pour peupler une API, rejouer une série d’appels ou vérifier un ensemble d’adresses sans écrire de script.
Une liste d’appels, un seul envoi
Plutôt que de lancer vos requêtes une à une, ou d’écrire un script jetable pour une tâche ponctuelle, vous décrivez la série entière et l’outil l’exécute d’un bloc. C’est le bon niveau d’effort pour créer cent enregistrements de test, envoyer une salve d’appels à une API interne ou contrôler une liste d’URL, sans monter un projet pour une manipulation d’un quart d’heure.
Ce que vous contrôlez par appel
Chaque requête a ses propres réglages : la méthode — GET, POST, PUT, DELETE —, l’URL, les en-têtes, dont un jeton d’autorisation, et le corps.
Lire les résultats
Repérer d’un coup d’œil les appels réussis et ceux qui ont échoué, avec leur message d’erreur, vous évite de relancer aveuglément : vous voyez précisément quelle requête n’est pas passée et pourquoi, et vous corrigez celle-là seule au lieu de tout recommencer. Pour chaque appel, vous récupérez le code de statut HTTP et le corps de la réponse, regroupés dans un même résultat.
Sur le web ou en API
Le coût reste ainsi proportionnel à ce que vous lancez, sans engagement dans le temps. Vous composez et lancez votre lot depuis cette page, ou vous déclenchez l’opération via l’API pour l’intégrer à un traitement plus large, d’autres canaux étant prévus. La capacité est facturée à l’usage, $0.002 par requête en dollars US : vous ne payez que les appels réellement exécutés, tarif affiché, sans abonnement.
Cas d'intégration
Peupler un environnement de test
Julien doit créer cinquante fiches clients pour une démo. Il décrit cinquante appels POST vers l’API de son application et les lance en une fois, au lieu de cliquer cinquante fois dans une interface.
Rejouer des appels après une panne
Une série de webhooks n’est pas partie pendant une interruption. L’équipe de Studio Lumen SAS rejoue les appels manqués en un lot, en vérifiant le statut de chacun.
Questions techniques
Puis-je définir des en-têtes différents par appel ?
Oui. Chaque requête porte ses propres méthode, en-têtes et corps, y compris un jeton d’autorisation distinct. Vous pouvez donc mélanger des appels hétérogènes dans un même lot.