> 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

## Prérequis

Vous devez avoir déjà envoyé un fichier ou une URL comme décrit dans le [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 avez envoyé via polling (ou polling et webhook), vous obtiendrez la réponse directement dans votre appel de méthode.

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

Nous allons voir ici comment traiter au mieux les résultats.

## Charger depuis un webhook

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

La lecture des données du callback variera énormément selon votre serveur HTTP.\
Cela dépasse donc le 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é, 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 secret de signature du webhook :

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

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

```python
from mindee import LocalResponse, InferenceResponse

# Chargez la chaîne JSON envoyée par le rappel 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érifier 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("Mauvaise signature HMAC ! Quelqu'un essaie-t-il de faire le mal ?")

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

{% endtab %}

{% tab title="Node.js" %}
En supposant que vous puissiez récupérer 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("Mauvaise signature HMAC ! Quelqu'un essaie-t-il de faire le mal ?");
  }
  const response = await localResponse.deserializeResponse(
    mindee.InferenceResponse
  );
}

// Chargez la chaîne JSON envoyée par le rappel 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érifier 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 l'intégralité du corps de la réponse avec l'en-tête de signature
    await handleMindeeResponse(body, hmacSignature);
  });
}
```

{% endtab %}

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

```ruby
require 'mindee'

# Chargez la chaîne JSON envoyée par le rappel 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érifier 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 récupérer la requête HTTP brute via la variable `$requestBody` .

```php
<?php
  use Mindee\Input\LocalResponse;
  use Mindee\Error\MindeeException;
  use Mindee\Parsing\V2\InferenceResponse;

  // Chargez la chaîne JSON envoyée par le rappel POST du webhook Mindee.
  $localResponse = new LocalResponse($requestBody);
  
  // Ou charger depuis un chemin de fichier :
  // $localResponse = new LocalResponse($filePath);

  // Facultatif : vérifier la signature HMAC.
  if (!$localResponse->isValidHmacSignature($mySecretKey, 'dummy signature')){
    throw new MindeeException("Signature HMAC invalide !");
  }
  
  // Désérialisez la réponse :
  $response = $localResponse->deserializeResponse(InferenceResponse::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

// Chargez la chaîne JSON envoyée par le rappel 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("Mauvaise signature HMAC ! 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
InferenceResponse response = localResponse.deserializeResponse(
    InferenceResponse.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 récupérer 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("Mauvaise signature HMAC ! 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 d'inférence](#the-inference-object).

L'objet 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 import InferenceResponse

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

{% endtab %}

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

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

{% endtab %}

{% tab title="PHP" %}

```php
use Mindee\Parsing\V2\InferenceResponse;

public function handleResponse(InferenceResponse $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.parsing.v2.InferenceResponse;

public void handleResponse(InferenceResponse 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 d'inférence

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.
  * Champs : Pour gérer les champs extraits, voir le [Résultat d'Extraction](/v2/fr/modeles-extraction/sdk-integration/extraction-result.md) section.
  * Texte brut : 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.

En utilisant l'objet Response à partir d'une réponse de polling ou d'une charge utile webhook :

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

```python
from mindee import InferenceResponse
from mindee.parsing.v2 import InferenceFile

def handle_response(response: InferenceResponse):
    inference_file: InferenceFile = response.inference.file

    # différents 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;

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

{% endtab %}

{% tab title="PHP" %}

```php
use Mindee\Parsing\V2\InferenceResponse;

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

    // différents 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

  # différents 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.parsing.v2.InferenceFile;
import com.mindee.parsing.v2.InferenceResponse;

public void handleResponse(InferenceResponse response) {
    InferenceFile file = response.inference.getFile();

    // différents 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;

    // différents 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:

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

The question should be specific, self-contained, and written in natural language.
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.