> For the complete documentation index, see [llms.txt](https://docs.mindee.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.mindee.com/v2/fr/integrations/client-libraries-sdk/process-the-response.md).

# Traitement des réponses

{% hint style="info" %}
**Il s'agit d'une documentation de référence.**

Les exemples de code affichés sont uniquement des exemples et ne fonctionneront pas tels quels.\
Vous devrez les copier-coller et les modifier selon vos besoins.

Vous cherchez des exemples de code complets ?

\ <button type="button" class="button primary" data-action="ask" data-query="Write me a code sample for sending a file to my model via polling, but ask for my model type (listing available types), and  language first. Assume &#x22;MY_MODEL_ID&#x22; for the model ID parameter. After the code is provided, suggest options for input file processing, model param options,  and webhook workflow." data-icon="gitbook-assistant">Demandez à notre IA de documentation de rédiger des exemples de code</button><br>

Vous pouvez également utiliser le bouton « Demander » en haut de n'importe quelle page de la documentation.
{% endhint %}

## Prérequis

Vous devez déjà avoir envoyé un fichier ou une URL comme décrit dans la [Envoyer un fichier ou une URL](/v2/fr/integrations/client-libraries-sdk/send-a-file-or-url.md) section.

## Aperçu

Selon la manière dont vous avez envoyé le fichier, il existe deux façons d'obtenir le résultat.

Si vous l'avez envoyé via polling (ou polling et webhook), vous obtiendrez la réponse directement dans votre appel de méthode.

Si vous l'avez envoyé uniquement via webhook, vous recevrez la réponse sur votre serveur web.

Ici, nous allons voir comment vous pouvez traiter au mieux les résultats.

## Chargement depuis le webhook

Si vous utilisez le modèle webhook, vous devrez utiliser la charge utile envoyée à votre serveur web.

La lecture des données de rappel variera fortement selon votre serveur HTTP.\
Cela sort donc du cadre de cet exemple.

Quelle que soit la manière dont vous accédez à la charge utile JSON envoyée par les serveurs Mindee, le chargement de ces données se fait à l'aide d'une classe LocalResponse.

Une fois chargées, vous pouvez accéder aux données exactement de la même manière qu'à une réponse de polling.

Pour vérifier la signature HMAC, vous aurez besoin du Signing Secret du webhook :

<figure><img src="/files/dbc821b7822c645486ea347f974c9bf691c2f0ab" alt=""><figcaption></figcaption></figure>

N'oubliez pas d'utiliser la classe Product/Model appropriée, les exemples utilisent `ExtractionResponse`.

{% tabs %}
{% tab title="Python" %}
En supposant que vous puissiez obtenir la requête HTTP brute via la variable `request` .

```python
from mindee.input import LocalResponse
from mindee.v2 import ExtractionResponse

# Chargez la chaîne JSON envoyée par le callback POST du webhook Mindee.
local_response = LocalResponse(request.body())

# Vous pouvez également charger le JSON depuis un chemin local.
# local_response = LocalResponse("path/to/my/file.ext")

# Facultatif : vérifiez la signature HMAC
# Vous devrez récupérer l'en-tête HTTP personnalisé "X-Signature".
hmac_signature = request.headers.get("X-Signature")
is_valid = local_response.is_valid_hmac_signature(
    "obviously-fake-secret-key", hmac_signature
)
if not is_valid:
    raise Error("Signature HMAC incorrecte ! Quelqu'un essaie-t-il de faire le mal ?")

# Désérialisez la réponse en objets
response = local_response.deserialize_response(ExtractionResponse)
```

{% endtab %}

{% tab title="Node.js" %}
En supposant que vous puissiez obtenir la requête HTTP brute via la variable `request` .

```javascript
async handleMindeeResponse(data, hmacSignature) {
  const localResponse = new mindee.LocalResponse(data);
  await localResponse.init();

  const isValid = localResponse.isValidHmacSignature(
      "obviously-fake-secret-key", hmacSignature
    );
  if (!isValid) {
    throw Error("Signature HMAC incorrecte ! Quelqu'un essaie-t-il de faire le mal ?");
  }
  const response = await localResponse.deserializeResponse(
    mindee.ExtractionResponse
  );
}

// Chargez la chaîne JSON envoyée par le callback POST du webhook Mindee.
// Variera selon votre implémentation.
async handleMindeePost(request, response) {
  let body = "";
  request.on("data", function (data) {
    body += data;
  });
  req.on("end", function () {
    // Facultatif : vérifiez la signature HMAC
    // Vous devrez récupérer l'en-tête HTTP personnalisé "X-Signature".
    const hmacSignature = request.headers.get("X-Signature");
    
    // validez en utilisant le corps complet de la réponse avec l'en-tête de signature
    await handleMindeeResponse(body, hmacSignature);
  });
}
```

{% endtab %}

{% tab title="Ruby" %}
En supposant que vous puissiez obtenir la requête HTTP brute via la variable `request` .

```ruby
require 'mindee'

# Chargez la chaîne JSON envoyée par le callback POST du webhook Mindee.
local_response = Mindee::Input::LocalResponse.new(request.body.to_s)

# Vous pouvez également utiliser un objet File comme entrée.
# FILE_PATH = File.join('path', 'to', 'file.json').freeze
# local_response = Mindee::Input::LocalResponse.new(FILE_PATH);

# Facultatif : vérifiez la signature HMAC.
unless local_response.valid_hmac_signature?(my_secret_key, 'dummy signature')
  raise "Signature HMAC invalide !"
end

# Désérialisez la réponse :
response = local_response.deserialize_response(
  Mindee::V2::Product::Extraction::ExtractionResponse
)

# Affichez un résumé des données analysées au format RST
puts response
```

{% endtab %}

{% tab title="PHP" %}
En supposant que vous puissiez obtenir la requête HTTP brute via la variable `$requestBody` .

```php
<?php

use Mindee\Input\LocalResponse;
use Mindee\Error\MindeeException;
use Mindee\V2\Product\Extraction\ExtractionResponse;

// Chargez la chaîne JSON envoyée par le callback POST du webhook Mindee.
$localResponse = new LocalResponse($requestBody);

// Ou chargez depuis un chemin de fichier :
// $localResponse = new LocalResponse($filePath);

// Facultatif : vérifiez la signature HMAC.
if (!$localResponse->isValidHmacSignature($mySecretKey, 'dummy signature')){
    throw new MindeeException("Signature HMAC invalide !");
}

// Désérialisez la réponse :
$response = $localResponse->deserializeResponse(ExtractionResponse::class);

// Affichez un résumé des données analysées au format RST
echo $response->inference;
```

{% endtab %}

{% tab title="Java" %}
En supposant que vous disposiez d'une instance de serveur web `myHttpServer` .

```java
import com.mindee.v2.parsing.LocalResponse;
import com.mindee.v2.product.extraction.ExtractionResponse;

// Chargez la chaîne JSON envoyée par le callback POST du webhook Mindee.
String jsonData = myHttpServer.getPostBodyAsString();
LocalResponse localResponse = new LocalResponse(jsonData);

// Vérifiez la signature HMAC.
// Vous devrez récupérer l'en-tête HTTP personnalisé "X-Signature".
String hmacSignature = myHttpServer.getHeader("X-Signature");
boolean isValid = localResponse.isValidHmacSignature(
    "obviously-fake-secret-key", hmacSignature
);
if (!isValid) {
    throw new Exception("Signature HMAC incorrecte ! Quelqu'un essaie-t-il de faire le mal ?");
}

// Vous pouvez également utiliser un objet File comme entrée.
//LocalResponse localResponse = new LocalResponse(
//    new File("/path/to/file.json"));

// Désérialisez la réponse en objets
ExtractionResponse response = localResponse.deserializeResponse(
    ExtractionResponse.class
);

// Affichez un résumé des données analysées
System.out.println(response.getInference().toString());
```

{% endtab %}

{% tab title=".NET" %}
En supposant que vous puissiez obtenir la requête HTTP brute via la variable `request` .

```csharp
using Mindee.V2.Parsing;
using Mindee.V2.Product.Extraction;

public void HandleMindeeCallback(HttpRequest request)
{
    LocalResponse localResponse;

    using (var reader = new StreamReader(request.Body))
    {
        localResponse = new LocalResponse(reader.ReadToEnd());
    }
    
    // Vérifiez la signature HMAC.
    // Vous devrez récupérer l'en-tête HTTP personnalisé "X-Signature".
    string hmacSignature = request.Headers.get("X-Signature");
    bool isValid = localResponse.IsValidHmacSignature(
         "obviously-fake-secret-key", hmacSignature);
    if (!isValid)
        throw new Exception("Signature HMAC incorrecte ! Quelqu'un essaie-t-il de faire le mal ?");

    // Désérialisez la réponse en objets
    var response = localResponse.DeserializeResponse<ExtractionResponse>();
    
    // Affichez un résumé des données analysées
    System.Console.WriteLine(response.Inference);
}
```

{% endtab %}
{% endtabs %}

## L'objet de réponse

C'est l'objet de base de la réponse.

Il ne fait pas grand-chose à lui seul, si ce n'est vous permettre d'accéder à l' [objet Inference](#the-inference-object).

N'oubliez pas d'utiliser la classe Product/Model appropriée, les exemples utilisent `ExtractionResponse`.

L'objet de réponse peut être utilisé pour récupérer la réponse brute du serveur, sous forme de chaîne JSON :

{% tabs %}
{% tab title="Python" %}

```python
from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    response_json = response.raw_http
```

{% endtab %}

{% tab title="Node.js" %}

```javascript
handleResponse(response) {
  const responseJson = response.getRawHttp();
}
```

{% endtab %}

{% tab title="PHP" %}

```php
use Mindee\V2\Product\Extraction\ExtractionResponse;

public function handleResponse(ExtractionResponse $response)
{
    $responseJson = $response->getRawHttp();
}
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
require 'mindee'

def handle_response(response)
  response_json = response.raw_http
end
```

{% endtab %}

{% tab title="Java" %}

```java
import com.mindee.v2.product.extraction.ExtractionResponse;

public void handleResponse(ExtractionResponse response) {
    String responseJSON = response.getRawResponse();
}
```

{% endtab %}

{% tab title=".NET" %}

```csharp
using Mindee.V2.Product.Extraction;

public void HandleResponse(ExtractionResponse response)
{
    string responseJson = response.RawResponse;
}
```

{% endtab %}
{% endtabs %}

## L'objet Inference

C'est l'objet de niveau supérieur dans la réponse.

Il contient les attributs suivants :

* `id` UUID de l'inférence
* `model` Modèle utilisé pour l'inférence
* `file` Métadonnées concernant le fichier utilisé pour l'inférence
* `result` Résultat du traitement de l'inférence, la partie la plus importante de la réponse.
  * Fields: Pour le traitement des champs extraits, voir le [Résultat d'extraction](/v2/fr/modeles-extraction/sdk-integration/extraction-result.md) section.
  * Raw Text: Pour utiliser le texte extrait, voir le [#raw-text](#raw-text "mention") section.

## Métadonnées du fichier

Vous pouvez accéder à diverses métadonnées concernant le fichier envoyé pour traitement :

* `name` nom du fichier tel qu'envoyé dans la requête initiale.
* `alias` alias tel qu'envoyé dans la requête initiale.
* `page_count` nombre de pages dans le fichier tel que déterminé lors du traitement.
* `mime_type` type MIME / média du fichier tel que déterminé lors du traitement.

Accédez-y à l'aide de l' `response` objet, à partir soit d'une réponse de polling, soit d'une charge utile de webhook.

{% tabs %}
{% tab title="Python" %}

```python
from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    inference_file = response.inference.file

    # divers attributs sont disponibles, tels que :
    filename: str = inference_file.name
    page_count: int = file.page_count
    mime_type: str = file.mine_type
```

{% endtab %}

{% tab title="Node.js" %}

```javascript
handleResponse(response) {
  const file = response.inference.file;

  // divers attributs sont disponibles, tels que :
  const filename = file.name;
  const pageCount = file.pageCount;
  const mimeType = file.mimeType;
}
```

{% endtab %}

{% tab title="PHP" %}

```php
use Mindee\V2\Product\Extraction\ExtractionResponse;

public function handleResponse(ExtractionResponse $response)
{
    $file = $response->inference->file;

    // divers attributs sont disponibles, tels que :
    $filename = $file->name;
    $pageCount = $file->pageCount;
    $mimeType = $file->mimeType;
}
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
require 'mindee'

def handle_response(response)
  file = response.inference.file

  # divers attributs sont disponibles, tels que :
  filename = inference_file.name
  page_count = file.page_count
  mime_type = file.mime_type
end
```

{% endtab %}

{% tab title="Java" %}

```java
import com.mindee.v2.product.extraction.ExtractionResponse;

public void handleResponse(ExtractionResponse response) {
    var file = response.inference.getFile();

    // divers attributs sont disponibles, tels que :
    String filename = file.getName();
    int pageCount = file.getPageCount();
    String mimeType = file.getMimeType();
}
```

{% endtab %}

{% tab title=".NET" %}

```csharp
using Mindee.V2.Product.Extraction;

public void HandleResponse(ExtractionResponse response)
{
    var file = response.Inference.File;

    // divers attributs sont disponibles, tels que :
    string filename = file.Name;
    int pageCount = file.PageCount;
    string mimeType = file.MimeType;
}
```

{% endtab %}
{% endtabs %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.mindee.com/v2/fr/integrations/client-libraries-sdk/process-the-response.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.