# Démarrage rapide

> Créez un espace de travail et une clé d’API, puis lancez vos premières vérifications de texte et d’image avec cURL, JavaScript fetch ou Python requests.

Source : https://fileverity.com/fr/docs/quickstart

Cette page vous guide de l’inscription à vos premiers résultats. Il vous faut un compte Fileverity, un terminal avec curl et jq et, pour l’exemple d’image, un fichier JPEG, PNG ou WebP.

## 1. Ouvrir la Console

Connectez-vous sur [fileverity.com/console](https://fileverity.com/console?lang=fr) avec un code reçu par courriel ou avec Google. Votre première connexion crée un espace de travail personnel doté de son propre solde prépayé.

Votre premier espace de travail démarre avec 5 vérifications gratuites d’images ou de documents et 5 000 caractères de texte gratuits. Aucune carte n’est nécessaire. Un démarrage gratuit par personne, et un nombre limité par domaine de messagerie d’entreprise. Vos collègues doivent rejoindre l’espace de travail sur invitation. Le démarrage gratuit est utilisé avant votre solde. Voir [Tarifs et facturation](https://fileverity.com/fr/docs/pricing.md#free-start).

## 2. Créer une clé d’API

Ouvrez **Clés API**, choisissez **Créer une clé**, donnez-lui un nom et choisissez un mode. Créez d’abord une clé **Test** : elle renvoie des résultats d’exemple fixes, n’appelle jamais de modèle et n’est jamais facturée. La clé complète n’est affichée qu’une seule fois : copiez-la dès maintenant.

Gardez la clé hors du contrôle de version et du code exécuté dans le navigateur. Exportez-la comme variable d’environnement :

**Environnement: Shell**

```bash
export FILEVERITY_API_KEY=fv_test_...
```

## 3. Vérifier votre clé

`GET /models` fonctionne avec n’importe quelle clé valide et n’est jamais facturé. Une réponse `200` qui liste les modèles signifie que la clé est valide. Une réponse `401` signifie que la clé est absente, mal saisie ou révoquée.

**Vérifier votre clé: cURL**

```bash
curl -i https://api.fileverity.com/v1/models \
  -H "Authorization: Bearer $FILEVERITY_API_KEY"
```

**Vérifier votre clé: JavaScript**

```javascript
const response = await fetch("https://api.fileverity.com/v1/models", {
  headers: { Authorization: "Bearer " + process.env.FILEVERITY_API_KEY },
});
console.log(response.status);
```

**Vérifier votre clé: Python**

```python
import os
import requests

response = requests.get("https://api.fileverity.com/v1/models", headers={"Authorization": "Bearer " + os.environ["FILEVERITY_API_KEY"]})
print(response.status_code)
```

## 4. Vérifier un texte

Envoyez du texte brut d’au moins 100 mots à `POST /text/detections`. Les exemples lisent le texte dans un fichier : enregistrez donc d’abord un passage de 100 mots ou plus sous le nom `essay.txt`. Cette commande écrit un exemple :

**Écrire essay.txt**

```bash
cat > essay.txt <<'EOF'
Honestly, the delivery was a mess. The driver turned up at six in the evening,
the pallet was wet on one side, and nobody at the depot would pick up the
phone until Monday. I photographed everything before signing, which is the
only reason we have a leg to stand on. In today's fast-paced logistics
landscape, it is essential for businesses to prioritize reliable delivery
performance, as timely and undamaged shipments play a pivotal role in
fostering customer trust and long-term satisfaction. We lost two days. Marta
rebuilt the schedule by hand and the Leeds order still went out late. Moving
forward, it is crucial to implement robust quality assurance measures and
establish clear communication channels, ensuring that all stakeholders remain
aligned and that potential issues are proactively addressed. For now I am
asking for a credit note and a named contact. Not another apology.
EOF
```

**Première vérification de texte: cURL**

```bash
curl https://api.fileverity.com/v1/text/detections \
  -H "Authorization: Bearer $FILEVERITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d "$(jq -Rs '{text: .}' essay.txt)"
```

**Première vérification de texte: JavaScript**

```javascript
import { readFile } from "node:fs/promises";

const response = await fetch("https://api.fileverity.com/v1/text/detections", {
  method: "POST",
  headers: {
    Authorization: "Bearer " + process.env.FILEVERITY_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ text: await readFile("essay.txt", "utf8") }),
});
const detection = await response.json();
if (!response.ok) throw new Error(detection.error.code + ": " + detection.error.message);
console.log(detection.verdict, detection.ai_fraction);
```

**Première vérification de texte: Python**

```python
import os
import requests

response = requests.post(
    "https://api.fileverity.com/v1/text/detections",
    headers={"Authorization": "Bearer " + os.environ["FILEVERITY_API_KEY"]},
    json={"text": open("essay.txt", encoding="utf-8").read()},
)
detection = response.json()
if not response.ok:
    raise RuntimeError(detection["error"]["code"] + ": " + detection["error"]["message"])
print(detection["verdict"], detection["ai_fraction"])
```

Avec une clé de test, la réponse est un résultat fixe correspondant à un texte rédigé par une personne. Avec une clé Live, elle ressemble à ceci :

**Réponse, clé Live**

```json
{
  "id": "tdet_8Hk2pQ4vN9sL1xR7cW3mY6zB",
  "object": "text.detection",
  "created": 1793664000,
  "model": "fvdoc-3-text-2026-11-03",
  "livemode": true,
  "language": "en",
  "verdict": "mixed",
  "score": 0.97,
  "ai_fraction": 0.41,
  "segments": [
    {
      "start": 212,
      "end": 433,
      "score": 0.97
    },
    {
      "start": 579,
      "end": 790,
      "score": 0.93
    }
  ],
  "usage": {
    "characters": 1412,
    "free_characters": 0,
    "billed_units": 2
  }
}
```

Les détails, y compris le fonctionnement des positions, figurent dans [Détections de texte](https://fileverity.com/fr/docs/text-detections.md).

## 5. Vérifier une image

Les images et les documents demandent deux appels : téléversez le fichier, puis créez une analyse qui s’y réfère. Une analyse est une vérification d’image ou de document. `Prefer: wait=60` maintient la requête ouverte jusqu’à ce que le résultat soit prêt, pendant 60 secondes au maximum.

**Première vérification d’image: cURL**

```bash
FILE_ID=$(curl -s https://api.fileverity.com/v1/files \
  -H "Authorization: Bearer $FILEVERITY_API_KEY" \
  -F file=@photo.jpg | jq -r .id)

curl https://api.fileverity.com/v1/analyses \
  -H "Authorization: Bearer $FILEVERITY_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Prefer: wait=60" \
  -d "{\"model\": \"fvimg-2\", \"file\": \"$FILE_ID\"}"
```

**Première vérification d’image: JavaScript**

```javascript
import { readFile } from "node:fs/promises";

const headers = { Authorization: "Bearer " + process.env.FILEVERITY_API_KEY };

const form = new FormData();
form.append("file", new Blob([await readFile("photo.jpg")], { type: "image/jpeg" }), "photo.jpg");
const file = await (await fetch("https://api.fileverity.com/v1/files", { method: "POST", headers, body: form })).json();

const response = await fetch("https://api.fileverity.com/v1/analyses", {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json", Prefer: "wait=60" },
  body: JSON.stringify({ model: "fvimg-2", file: file.id }),
});
const analysis = await response.json();
console.log(analysis.status, analysis.summary, analysis.report_url);
```

**Première vérification d’image: Python**

```python
import os
import requests

headers = {"Authorization": "Bearer " + os.environ["FILEVERITY_API_KEY"]}

file = requests.post("https://api.fileverity.com/v1/files", headers=headers, files={"file": open("photo.jpg", "rb")}).json()

response = requests.post(
    "https://api.fileverity.com/v1/analyses",
    headers={**headers, "Prefer": "wait=60"},
    json={"model": "fvimg-2", "file": file["id"]},
)
analysis = response.json()
print(analysis["status"], analysis["summary"], analysis["report_url"])
```

Une analyse terminée renvoie `200` avec `status: succeeded`, un court `summary` et le `result.report` complet. Si l’attente expire avant, vous obtenez `202` avec `status: processing` ; récupérez-la plus tard avec `GET /analyses/{id}` ou recevez un webhook. Voir [Analyses](https://fileverity.com/fr/docs/analyses.md).

**Réponse, clé Live**

```json
{
  "id": "an_8Hk2pQ4vN9sL1xR7cW3mY6zB",
  "object": "analysis",
  "created": 1793700120,
  "model": "fvimg-2-2026-10-30",
  "livemode": true,
  "status": "succeeded",
  "file": {
    "name": "claim-photo.jpg",
    "bytes": 2481920,
    "format": "jpeg"
  },
  "report_id": "FV-7K2M-9QXD-4T8R",
  "report_url": "https://fileverity.com/verify/FV-7K2M-9QXD-4T8R",
  "summary": {
    "level": "L2",
    "assessment": "authentic_untouched",
    "action": "accept",
    "ai": "very_low",
    "edit": "none"
  },
  "result": {
    "report": {
      "schema": "fileverity.report/1",
      "id": "FV-7K2M-9QXD-4T8R"
    },
    "stamped_at": 1793700130
  },
  "error": null,
  "progress": null,
  "usage": {
    "amount": 199,
    "currency": "usd",
    "funding": "balance"
  },
  "metadata": {
    "order_id": "A-10492"
  },
  "completed_at": 1793700131,
  "expires_at": 1794304931
}
```

> **Remarque.** Avec une clé de test, le fichier est validé mais pas conservé, et l’analyse renvoie immédiatement un exemple fixe. Son ID de rapport commence par `FV-TEST-` et n’a pas de page de vérification publique.

## 6. Passer en production

- Créez une clé **Live** dans la Console et utilisez-la à la place de la clé de test. Le même code fonctionne sans modification.
- Utilisez le démarrage gratuit, ou ajoutez des fonds au solde de votre espace de travail dans **Solde**. La recharge minimale est de 19 $ US.
- Définissez une limite de dépense mensuelle pour la clé et ajoutez un [point de terminaison webhook](https://fileverity.com/fr/docs/webhooks.md) plutôt que d’interroger l’API.
- Envoyez une `Idempotency-Key` avec les requêtes POST pour qu’une nouvelle tentative ne lance jamais une vérification deux fois. Voir [Idempotence](https://fileverity.com/fr/docs/idempotency.md).

Pour savoir ce que chaque vérification examine et où les équipes l’utilisent, consultez l’[API de détection d’images IA](https://fileverity.com/fr/api/detection-d-images-ia) et l’[API de détection de fraude documentaire](https://fileverity.com/fr/api/detection-de-fraude-documentaire).

Ensuite : les [Exemples de code](https://fileverity.com/fr/docs/sample-code.md) contiennent des programmes Node.js et Python complets pour chaque vérification et pour les webhooks. Lisez ensuite [Authentification et clés](https://fileverity.com/fr/docs/authentication.md), [Erreurs](https://fileverity.com/fr/docs/errors.md) et la [référence de l’API](https://fileverity.com/fr/docs/api-reference.md). Si quelque chose ne fonctionne pas, écrivez à [hello@fileverity.com](mailto:hello@fileverity.com) ou utilisez la [page de contact](https://fileverity.com/fr/contact), en indiquant l’ID de requête de l’en-tête `x-request-id`.