> ## Documentation Index
> Fetch the complete documentation index at: https://docs.samsa.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Vérifier une image ou une vidéo

> Envoie un fichier et obtiens un résultat technique par technique, avec le verdict C2PA comme réponse faisant autorité.

```
POST https://detect.samsa.ai/v1/public/detect
```

Envoie une seule image ou vidéo en `multipart/form-data`. La réponse porte un verdict
global `detected` ainsi qu'un détail par technique. Pas d'authentification, pas de
crédits. Le fichier envoyé est **traité en mémoire et jamais conservé**.

## Requête

Envoie exactement **une** partie fichier nommée `file`. La partie doit porter un
`filename` dans son en-tête `Content-Disposition` — un simple champ de formulaire sans
nom de fichier n'est pas une partie fichier.

|                     |                                         |
| ------------------- | --------------------------------------- |
| **Content-Type**    | `multipart/form-data`                   |
| **Champ**           | `file` — l'image ou la vidéo à vérifier |
| **Taille max.**     | 50 Mo                                   |
| **Formats d'image** | JPEG, PNG, WebP, GIF                    |
| **Formats vidéo**   | MP4, QuickTime, WebM                    |

<Note>
  JPEG/PNG/WebP/GIF et MP4/QuickTime sont reconnus par leurs magic bytes : un
  `Content-Type` de partie erroné ou générique (par exemple `application/octet-stream`)
  n'empêche donc pas la détection pour ces formats. **WebM n'a pas de branche
  magic-byte** et n'est accepté que si la partie déclare `Content-Type: video/webm`.
</Note>

<CodeGroup>
  ```bash curl theme={null}
  curl -X POST https://detect.samsa.ai/v1/public/detect \
    -F "file=@photo.jpg"
  ```

  ```python Python theme={null}
  import requests

  with open("photo.jpg", "rb") as fh:
      response = requests.post(
          "https://detect.samsa.ai/v1/public/detect",
          files={"file": ("photo.jpg", fh, "image/jpeg")},
          timeout=120,
      )

  response.raise_for_status()
  result = response.json()
  print(result["detected"])
  ```

  ```typescript TypeScript theme={null}
  import { readFile } from "node:fs/promises";

  const form = new FormData();
  // The third argument sets the part filename — required for it to count as a file part.
  form.append("file", new Blob([await readFile("photo.jpg")]), "photo.jpg");

  const response = await fetch("https://detect.samsa.ai/v1/public/detect", {
    method: "POST",
    body: form,
  });

  if (!response.ok) {
    const { detail } = await response.json();
    throw new Error(`Detection failed (${response.status}): ${detail}`);
  }

  const result = await response.json();
  console.log(result.detected);
  ```
</CodeGroup>

## Réponse

`200 OK`. Une image ou une vidéo portant un manifeste C2PA Samsa valide et de
confiance :

```json Response theme={null}
{
  "request_id": "c1a2b3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d",
  "detected": "samsa",
  "techniques": [
    {
      "type": "metadata",
      "result": "samsa",
      "confidence": "high",
      "manifest": {
        "claim_generator": "Samsa/1.0",
        "digital_source_type": "http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia",
        "upstream_provider": "fal",
        "upstream_model": "flux-pro",
        "timestamp": "2026-07-02T14:21:07+00:00",
        "assertions": ["c2pa.actions", "c2pa.hash.data"]
      }
    },
    {
      "type": "watermark",
      "result": "not_checked",
      "confidence": null,
      "vendor_id": null
    },
    {
      "type": "watermark",
      "result": "not_checked",
      "confidence": null,
      "vendor_id": null
    }
  ],
  "external_verification": {
    "c2pa": "https://verify.contentauthenticity.org"
  },
  "result_pdf_url": "https://detect.samsa.ai/v1/public/detect/result/c1a2b3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d/pdf",
  "responded_at": "2026-07-02T14:21:09.412093Z"
}
```

| Champ                   | Type              | Description                                                                                                                                        |
| ----------------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `request_id`            | string (UUID)     | Identifiant généré par le serveur pour cette vérification. Utilise-le pour récupérer le [PDF de résultat signé](/fr/content-verification/results). |
| `detected`              | enum              | Le verdict global : `samsa`, `non_samsa` ou `unknown`.                                                                                             |
| `techniques[]`          | array             | Une entrée par technique appliquée — voir [ci-dessous](#comprendre-chaque-technique).                                                              |
| `external_verification` | object            | Liens pour vérifier le résultat indépendamment de Samsa. Actuellement `c2pa`.                                                                      |
| `result_pdf_url`        | string \| null    | Lien vers le PDF signé de ce résultat, ou `null` quand la persistance des résultats est indisponible.                                              |
| `responded_at`          | string (ISO 8601) | Moment où la vérification s'est terminée, en UTC.                                                                                                  |

<Note>
  `result_pdf_url` peut être `null`. Lorsqu'elle est présente, **suis-la exactement
  telle qu'elle est renvoyée** plutôt que de composer l'URL toi-même — elle et
  l'[endpoint de résultat documenté](/fr/content-verification/results) servent le même
  PDF signé.
</Note>

### Le verdict `detected`

Le verdict provient de la vérification du manifeste C2PA, qui fait autorité. Les
techniques de filigrane sont de la corroboration : elles peuvent fournir une attribution
en l'absence de manifeste, mais ne remplacent jamais un verdict issu d'un manifeste.

| `detected`  | Atteint quand                                                                                                                                        |
| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `samsa`     | Un manifeste Samsa valide, de confiance et autorisé a été vérifié — ou, sans manifeste, un décodage de filigrane a renvoyé une correspondance Samsa. |
| `non_samsa` | Un manifeste est présent mais n'est pas attribuable à Samsa (autre émetteur, non fiable, ou altéré).                                                 |
| `unknown`   | Aucun manifeste présent et aucune correspondance de filigrane.                                                                                       |

<Warning>
  `unknown` signifie que **cette vérification n'a trouvé aucune preuve**, et non que le
  fichier est authentique ou créé par un humain. Les métadonnées de provenance
  s'effacent facilement, et le décodage hébergé des filigranes
  [n'est pas encore disponible](#comprendre-chaque-technique).
</Warning>

## Comprendre chaque technique

`techniques[]` commence toujours par l'unique entrée `metadata` (la couche C2PA faisant
autorité), suivie des techniques de filigrane applicables à la modalité du fichier.

### La technique `metadata`

```json theme={null}
{
  "type": "metadata",
  "result": "absent",
  "confidence": "low",
  "manifest": null
}
```

| Champ        | Description                                                                                                                                                                                                                                                     |
| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `result`     | `samsa` (manifeste Samsa valide, de confiance et autorisé), `non_samsa` (manifeste d'un autre émetteur, ou valide mais non fiable), `tampered` (manifeste qui échoue à la validation) ou `absent` (aucun manifeste — le plus souvent parce qu'il a été effacé). |
| `confidence` | `high`, `medium` ou `low`. Toujours présent pour cette technique.                                                                                                                                                                                               |
| `manifest`   | Un résumé compréhensible du manifeste vérifié (`claim_generator`, `digital_source_type`, `upstream_provider`, `upstream_model`, `timestamp`, `assertions`), ou `null` quand il n'y a rien à résumer.                                                            |

<Info>
  La vérification du manifeste C2PA est **en service** : elle est fournie par l'API
  publique Samsa et par tout validateur C2PA indépendant. L'attribution d'un manifeste à
  Samsa deviendra disponible une fois la signature de production activée.
</Info>

### Les techniques de filigrane

```json theme={null}
{
  "type": "watermark",
  "result": "not_checked",
  "confidence": null,
  "vendor_id": null
}
```

| Champ        | Description                                                                                                            |
| ------------ | ---------------------------------------------------------------------------------------------------------------------- |
| `result`     | `samsa`, `absent`, `low_confidence` ou `not_checked` — voir le tableau ci-dessous.                                     |
| `confidence` | `high`, `medium` ou `low`, et `null` **si et seulement si** `result` vaut `not_checked`. La clé est toujours présente. |
| `vendor_id`  | Identifie le décodeur à l'origine d'une correspondance ; `null` sauf si `result` vaut `samsa`.                         |

| `result`         | Signification                                                                               |
| ---------------- | ------------------------------------------------------------------------------------------- |
| `samsa`          | Un décodeur s'est exécuté et a trouvé un filigrane Samsa.                                   |
| `absent`         | Un décodeur s'est exécuté et n'a trouvé aucun filigrane Samsa.                              |
| `low_confidence` | Un décodeur s'est exécuté et a renvoyé une correspondance faible.                           |
| `not_checked`    | Le backend du décodeur n'est pas provisionné, donc **la technique n'a jamais été évaluée**. |

<Warning>
  `not_checked` n'affirme **pas** qu'aucun filigrane n'est présent — c'est ce que
  signifie `absent`. Le décodage hébergé des filigranes n'est pas encore disponible ; il
  est prévu avant le 2 février 2027. D'ici là, l'API signale ces techniques comme
  `not_checked`, jamais comme un faux « aucun filigrane ». N'affiche jamais une technique
  `not_checked` comme un filigrane absent.
</Warning>

Comme le décodage hébergé des filigranes n'est pas encore en service, chaque entrée de
filigrane revient actuellement en `not_checked` avec `confidence: null`. Les entrées de
filigrane ne portent pas de nom de technique propre — pour les identifiants
d'algorithme, les empreintes des artefacts de modèle épinglés, les libellés de
soft-binding par voie de signature et les décodeurs open source derrière chaque
technique, lis
[Comment fonctionne la détection](https://detect.samsa.ai/how-detection-works) ou
[`GET /v1/public/detect/info`](/fr/content-verification/info).

## Erreurs

Les erreurs renvoient `{"detail": "…"}` — et non l'
[enveloppe d'erreur](/fr/guides/errors) de l'API REST Samsa.

| Statut | Quand                                                                                                                        |
| ------ | ---------------------------------------------------------------------------------------------------------------------------- |
| `400`  | Corps multipart malformé, boundary manquante, envoi vide, ou un nombre de parties fichier différent de exactement une.       |
| `413`  | L'envoi dépasse la limite de 50 Mo.                                                                                          |
| `415`  | La requête n'est pas en `multipart/form-data`, ou les octets envoyés ne sont pas une image ou une vidéo prise en charge.     |
| `503`  | Un décodeur disponible ou le vérificateur C2PA a échoué au moment de l'inférence. La réponse porte un en-tête `Retry-After`. |

<Tip>
  Traite `503` comme transitoire et réessaie après l'intervalle `Retry-After`. Un
  décodeur simplement non provisionné ne produit jamais de `503` — il se dégrade en
  `not_checked` dans une réponse `200` normale.
</Tip>
