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

# Postman

> Importez une collection et un environnement sandbox générés depuis openapi.json, puis exécutez les appels avec des contrôles intégrés.

Deux fichiers, générés depuis [`openapi.json`](/openapi.json), permettent d'exécuter chaque endpoint depuis Postman ou Newman.

| Fichier | Contenu |
| - | - |
| `sahl-partner-api.postman_collection.json` | Collection v2.1 : sept requêtes avec des données fictives, des exemples de réponses enregistrés pour chaque statut que l'API peut renvoyer, une authentification bearer sur `{{apiKey}}` et de courts scripts de test. |
| `sahl-sandbox.postman_environment.json` | Environnement « Sahl sandbox » : `baseUrl`, `apiKey` (vide, secret), `environment` (`sandbox`), `reference` (`client-0001`). |

Aucune clé et aucun document ne figurent dans ces fichiers.

Copies texte pour l'import par lien : [collection](/postman/sahl-partner-api.postman_collection.json.txt) et [environnement](/postman/sahl-sandbox.postman_environment.json.txt). Elles contiennent le même JSON. Les fichiers `.json` se trouvent dans le dossier `postman/` du paquet de documentation.

## Importer

1. Ouvrez Postman. Cliquez sur **Import**.
2. Importez la collection. Choisissez une méthode :
   * **Link** : collez `https://docs.sahlfinancial.com/postman/sahl-partner-api.postman_collection.json.txt`.
   * **File** : choisissez le fichier téléchargé `sahl-partner-api.postman_collection.json`.
   * **Raw text** : ouvrez la copie texte ci-dessus, sélectionnez tout, collez.
3. Importez l'environnement de la même façon. Son contenu est assez court pour être collé ici :

```json theme={null}
{
  "id": "a85c6911-a553-5571-a8ac-05c299d21326",
  "name": "Sahl sandbox",
  "values": [
    {
      "key": "baseUrl",
      "value": "https://app.sahlfinancial.com/api",
      "type": "default",
      "enabled": true
    },
    {
      "key": "apiKey",
      "value": "",
      "type": "secret",
      "enabled": true
    },
    {
      "key": "environment",
      "value": "sandbox",
      "type": "default",
      "enabled": true
    },
    {
      "key": "reference",
      "value": "client-0001",
      "type": "default",
      "enabled": true
    }
  ],
  "_postman_variable_scope": "environment",
  "_postman_exported_using": "sahl-docs"
}
```

4. Sélectionnez **Sahl sandbox** dans le menu des environnements en haut à droite.
5. Ouvrez l'environnement et renseignez **Current value** de `apiKey` avec votre propre clé. Utilisez la valeur courante, pas la valeur initiale : Postman garde les valeurs courantes sur votre machine et peut synchroniser les valeurs initiales vers un espace de travail partagé. Créez la clé comme décrit dans [Tester en sandbox](/fr/test-in-sandbox#étape-1-créer-une-clé-sandbox).

Laissez `environment` à `sandbox`. `baseUrl` vaut `https://app.sahlfinancial.com/api`.

## Les requêtes

Exécutez-les dans l'ordre. Chacune enregistre ce dont la suivante a besoin.

| # | Requête | Envoie | Le script de test vérifie | Enregistre |
| - | - | - | - | - |
| 1 | Read a payslip | `POST /v1/kyc/extract`, form-data : `files`, `doc_type=payslip`, `reference`, `environment`, `subject`, `kind` | HTTP 200 ; la réponse contient `fields`, `documents`, `field_count`, `checks`, `reader_unavailable`, `policy` ; `reader_unavailable` est faux | `documents_payslip`, `caseId` |
| 2 | Read a national ID (CIN) | `POST /v1/kyc/extract` avec `doc_type=national_id` | Idem | `documents_id`, `caseId` |
| 3 | Verify a profile | `POST /v1/kyc/verify`, JSON avec `values` et les `documents` enregistrés | HTTP 200 ; `passed` est un booléen ; `checks` est un tableau ; la réponse contient `case_id` | `caseId` |
| 4 | Assess risk | `POST /v1/kyc/assess`, JSON avec les mêmes documents et les réponses d'adéquation | HTTP 200 ; la réponse contient `verification`, `assessment`, `registry` ; le niveau de conformité est `Low`, `Medium` ou `High` | |
| 5 | eID: start a check | `POST /v1/kyc/eid` | HTTP 201 ; `key` est un nombre | `eidKey` |
| 6 | eID: get the result | `GET /v1/kyc/eid/{key}?environment=sandbox` | HTTP 200 ; `complete` et `passed` sont des booléens | |
| 7 | eID: download the PDF report | `GET /v1/kyc/eid/{key}/report` | HTTP 200 ; `Content-Type` vaut `application/pdf` | |

Avant chaque requête, un script de la collection vérifie que `apiKey` est renseignée et ajoute un `X-Request-ID` neuf (un GUID) pour que vous retrouviez l'appel dans **Developers, Call log** dans la console.

<Warning>
  Les requêtes 5 à 7 lancent un vrai contrôle eID et envoient un email au client, même en sandbox. Ignorez-les si votre espace de travail n'a pas de compte chez un fournisseur eID, et remplacez l'email du corps par une adresse que vous contrôlez.
</Warning>

### Fichiers pour les requêtes 1 et 2

La collection ne contient aucun document. Dans les requêtes 1 et 2, ouvrez l'onglet **Body** et cliquez sur la ligne `files` pour choisir votre propre faux fichier de test. La collection les désigne par `payslip-test.pdf` et `cin-test.jpg` comme valeurs de remplacement. Fabriquez les fichiers vous-même avec des données inventées et n'envoyez aucun document réel de client : voir [Sandbox](/fr/sandbox#créer-un-faux-client-qui-se-comporte-bien).

### Variables

| Variable | Portée | Usage |
| - | - | - |
| `baseUrl` | environnement | `https://app.sahlfinancial.com/api` |
| `apiKey` | environnement, secret | Votre clé. Vide dans le fichier. |
| `environment` | environnement | `sandbox`. Envoyée comme champ `environment`. |
| `reference` | environnement | `client-0001`. Votre identifiant du client. Changez-la pour ouvrir un autre dossier. |
| `documents`, `documents_id`, `documents_payslip`, `caseId`, `eidKey` | collection | Renseignées par les scripts. |

Les requêtes 3 et 4 placent `{{documents}}` dans le corps JSON. L'éditeur de Postman peut le souligner comme du JSON invalide avant l'exécution. Il est remplacé par les entrées des requêtes 1 et 2 à l'envoi.

## Ce que font les scripts

Tous les scripts sont du code de sandbox Postman standard. Requête 1 :

```javascript theme={null}
pm.test("status is 200", function () { pm.response.to.have.status(200); });
const body = pm.response.json();
pm.test("answer has the documented keys", function () {
  ["fields", "documents", "field_count", "checks", "reader_unavailable", "policy"].forEach(function (k) { pm.expect(body).to.have.property(k); });
});
pm.test("the file was read", function () { pm.expect(body.reader_unavailable).to.eql(false); });
pm.collectionVariables.set("documents_payslip", JSON.stringify(body.documents));
if (body.case_id) { pm.collectionVariables.set("caseId", body.case_id); }
```

La requête 3 commence par joindre les entrées enregistrées :

```javascript theme={null}
const parts = ["documents_id", "documents_payslip"].map(function (k) { return JSON.parse(pm.collectionVariables.get(k) || "[]"); });
pm.collectionVariables.set("documents", JSON.stringify([].concat(parts[0], parts[1])));
```

Un verdict négatif reste un HTTP 200 : un test qui vérifie le 200 passe donc quand `passed` est faux. Ajoutez votre propre assertion si vous voulez qu'une exécution en échec fasse échouer le pipeline, par exemple `pm.expect(body.passed).to.eql(true)`.

## Exécuter en ligne de commande avec Newman

```bash theme={null}
npm install -g newman
newman run sahl-partner-api.postman_collection.json \
  -e sahl-sandbox.postman_environment.json \
  --env-var "apiKey=$SAHL_API_KEY" \
  --working-dir ./samples \
  --folder "1. Read a payslip" --folder "2. Read a national ID (CIN)" \
  --folder "3. Verify a profile" --folder "4. Assess risk"
```

Placez `payslip-test.pdf` et `cin-test.jpg` dans `./samples`. On donne ici à `--folder` les noms des requêtes afin d'ignorer les requêtes eID. La collection et ses scripts ont été exécutés avec Newman contre un serveur local de substitution, pas contre l'API réelle.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.