ForHosting KIT · Images

Détecter les objets d’une image

Cet outil repère les objets présents dans une image et en dresse la liste, avec leur position dans le cadre. Vous savez ce que contient un visuel sans l’ouvrir : combien d’éléments, où ils se trouvent, de quelle nature. C’est la base d’un inventaire, d’un contrôle ou d’un déclenchement automatique selon ce qui est détecté.

● Stablepar requête + par image$0.010

Lancer — $0.010 + $0.0575/image Voir l’API

Utilisez-le depuis WebAPIE-mailApp bientôtTelegram bientôt

Exécuter en ligne

Exécutez cette tâche sur nos serveurs, avec votre compte. Les outils gratuits tournent dans votre navigateur ; celui-ci est facturé sur votre solde KIT au prix affiché ci-dessus.

Ce que la détection renvoie

Pour chaque objet reconnu, l’outil indique sa nature et sa zone dans l’image. On obtient donc plus qu’une étiquette : une carte de ce qui est présent et où. Cela permet de compter les éléments d’une scène, de vérifier la présence d’un objet attendu ou, à l’inverse, de repérer un intrus. La sortie est structurée, exploitable par un traitement en aval plutôt que destinée à la seule lecture humaine.

Compter et vérifier

Beaucoup de contrôles se résument à une question de présence ou de nombre : y a-t-il bien un objet dans cette photo, combien d’articles sur ce cliché, tel élément figure-t-il dans le cadre ? La détection répond sans qu’un opérateur ouvre chaque image. Sur un flux régulier de visuels, ce repérage automatique évite le comptage manuel, tâche à la fois lente et sujette à l’erreur d’attention.

Déclencher un traitement selon le contenu

Parce que le résultat est structuré, il peut piloter la suite : router une image vers un circuit différent selon ce qu’elle contient, signaler celle où manque un élément attendu, isoler les cas à vérifier. La détection devient alors un maillon d’un flux plutôt qu’une fin en soi. Elle propose un repérage fiable sur les objets nets, à confirmer sur les scènes encombrées où les éléments se chevauchent.

Cas d’usage

Inventaire visuel

Atelier Garnier SARL compte les articles présents sur les photos d’un stock sans les recenser à la main, cliché par cliché.

Contrôle de conformité d’une photo

Une place de marché vérifie qu’un visuel de produit contient bien l’objet annoncé avant de valider une mise en ligne.

Tri d’un flux d’images

Studio Lumen SAS oriente les visuels reçus vers différents circuits selon les éléments détectés dans chaque image.

Repérage d’un élément attendu

Thomas Rousseau vérifie sur une série de photos de chantier la présence des équipements de sécurité requis.

Questions fréquentes

L’outil indique-t-il où se trouvent les objets ?

Oui. Pour chaque élément reconnu, il renvoie sa nature et sa zone dans l’image, ce qui permet de le localiser et non seulement de le nommer.

Peut-il compter les objets d’une image ?

Oui, tant que les éléments sont distincts. Sur une scène très encombrée où les objets se chevauchent, le comptage mérite une vérification.

Quelle différence avec le classement d’image ?

Le classement attribue une catégorie à l’image entière ; la détection liste les objets qu’elle contient, un par un, avec leur position.

Combien coûte une détection ?

Le tarif est de $0.010 par requête et $0.0575 par image, en dollars US, réglé à l’usage, sans abonnement.

Mes images sont-elles gardées après analyse ?

Non. Chaque image est transmise de façon chiffrée, analysée le temps de produire la liste, puis supprimée de nos serveurs.

La détection est-elle exhaustive ?

Elle repère les objets nets et bien visibles ; un élément partiellement masqué ou minuscule peut lui échapper. Contrôlez les scènes chargées.

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

POSThttps://api.kit.forhosting.com/image/detect-objects

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/image/detect-objects \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"image":"https://ejemplo.com/imagen.jpg"}'

const res = await fetch("https://api.kit.forhosting.com/image/detect-objects", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "image": "https://ejemplo.com/imagen.jpg"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/image/detect-objects",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "image": "https://ejemplo.com/imagen.jpg"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/image/detect-objects", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"image":"https://ejemplo.com/imagen.jpg"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"image":"https://ejemplo.com/imagen.jpg"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/image/detect-objects", 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

{
  "image": "https://ejemplo.com/imagen.jpg"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "image.detect_objects",
  "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

par requête$0.010

par image$0.0575

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

`max_mb`	15
`max_megapixels`	12

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.
`422`	`task_failed`	La tâche a échoué : elle ne vous est pas facturée.

Consulter la documentation complète du KIT →