> 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/modeles-extraction/sdk-integration/extraction-result.md).

# Résultat d'extraction

Vous devrez disposer d'un objet de réponse comme décrit dans la [Traitement des réponses](/v2/fr/integrations/client-libraries-sdk/process-the-response.md) section.

## Accéder aux champs du Schéma de données

Les champs sont entièrement dynamiques et dépendent de votre modèle [Aperçu du schéma de données](/v2/fr/modeles-extraction/data-schema.md).

Dans la bibliothèque cliente, vous aurez accès aux différents champs sous la forme d’un type de mappage clé-valeur (celui de Python `dict`, celui de Java `HashMap`, etc.).

L’accès à un champ se fait via son nom dans le Schéma de données.

Chaque champ sera de l’un des types suivants :

* Une seule valeur, `SimpleField` classe.
* Un objet imbriqué (sous-champs), `ObjectField` classe.
* Une liste ou un tableau de champs, `ListField` classe.

## `SimpleField` - Champ à valeur unique

Type de champ de base ayant l’ `value` attribut.\
Voir la [#value](#value "mention") section ci-dessous.

De plus, la `Simplefield` classe possède [#confidence](#confidence "mention") et [#locations](#locations "mention") attributs.

{% tabs %}
{% tab title="Python" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```python
from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields

    my_simple_field = fields.get_simple_field("my_simple_field")
```

{% endtab %}

{% tab title="Node.js" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

  const simpleField = fields.getSimpleField("my_simple_field");
}
```

{% endtab %}

{% tab title="PHP" %}
En utilisant la `$response` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

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

    $simpleField = $fields->getSimpleField('my_simple_field');
}
```

{% endtab %}

{% tab title="Ruby" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```ruby
def handle_response(response)
  fields = response.inference.result.fields

  simple_field = fields.get_simple_field('my_simple_field')
end
```

{% endtab %}

{% tab title="Java" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  SimpleField simpleField = fields.getSimpleField("my_simple_field");
}
```

{% endtab %}

{% tab title=".NET" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    SimpleField mySimpleField = fields["my_simple_field"].SimpleField;
}
```

{% endtab %}
{% endtabs %}

### `value`

La valeur de données extraite.\
Types possibles : chaîne, nombre (entier ou à virgule flottante), booléen.\
Tous les types peuvent être nuls.

Sur la plateforme, vous pouvez spécifier les types date et classification.\
Ceux-ci sont renvoyés sous forme de chaînes.

Pour les langages à typage statique (C#, Java), la bibliothèque cliente renverra toujours un `double` double nullable pour les valeurs numériques.

{% tabs %}
{% tab title="Python" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```python
from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
  fields = response.inference.result.fields

  # textes, dates, classifications ...
  string_field_value: str | None = fields.get_simple_field("string_field").value

  # un float JSON sera un float
  float_field_value: float | None = fields.get_simple_field("float_field").value

  # même si l’API renvoie toujours un entier, le type sera float
  int_field_value: float | None = fields.get_simple_field("int_field").value

  # booléens
  bool_field_value: bool | None = fields.get_simple_field("bool_field").value
```

{% endtab %}

{% tab title="Node.js" %}
L’ `value` attribut est un `Object` type Object en interne.

Vous devriez utiliser les accesseurs typés explicitement ; c’est recommandé pour plus de clarté.\
Consultez votre Schéma de données pour savoir quel accesseur typé utiliser.

```typescript
handleResponse(response) {
  const fields = response.inference.result.fields;
  
  // textes, dates, classifications ...
  const stringFieldValue = fields.getSimpleField("string_field").stringValue;
  
  // aucune distinction entre les nombres à virgule flottante et les entiers
  const floatFieldValue = fields.getSimpleField("float_field").numberValue;
  const intFieldValue = fields.getSimpleField("int_field").numberValue;
  
  // booléens
  const boolFieldValue = fields.getSimpleField("bool_field").booleanValue;
}
```

Si le mauvais type d’accesseur est utilisé, une exception sera levée, par exemple :

```
"La valeur n’est pas un nombre"
```

{% endtab %}

{% tab title="PHP" %}
En utilisant la `$response` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

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

    // textes, dates, classifications ...
    $stringFieldValue = $fields->getSimpleField('string_field')->value;

    // un float JSON sera un float
    $floatFieldValue = $fields->getSimpleField('float_field')->value;

    // même si l'API renvoie toujours un entier, le type sera float
    $intFieldValue = $fields->getSimpleField('int_field')->value;

    // booléens
    $boolFieldValue = $fields->getSimpleField('bool_field')->value;
}
```

{% endtab %}

{% tab title="Ruby" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```ruby
def handle_response(response)
  fields = response.inference.result.fields

  # textes, dates, classifications ...
  string_field_value = fields.get_simple_field('string_field').string_value

  # un float JSON sera un float
  float_field_value = fields.get_simple_field('float_field').float_value

  # même si l'API renvoie toujours un entier, le type sera float
  int_field_value = fields.get_simple_field('int_field').float_value

  # booléens
  bool_field_value = fields.get_simple_field('bool_field').boolean_value
end
```

{% endtab %}

{% tab title="Java" %}
L’ `value` attribut est un `Object` type Object en interne.

Vous devrez déclarer explicitement le type, sinon le code ne se compilera probablement pas.\
Consultez votre Schéma de données pour savoir quel type déclarer.

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

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  // textes, dates, classifications ...
  String stringFieldValue = fields.getSimpleField("string_field")
        .getStringValue();

  // un flottant JSON sera un Double
  Double floatFieldValue = fields.getSimpleField("float_field")
      .getDoubleValue();

  // même si l'API renvoie toujours un entier, le type sera Double
  Double intFieldValue = fields.getSimpleField("int_field")
      .getDoubleValue();

  // booléens
  Boolean boolFieldValue = fields.getSimpleField("bool_field")
      .getBooleanValue();
}
```

Si la mauvaise méthode de type est utilisée, une exception sera levée, par exemple :

```
ClassCast class java.lang.String cannot be cast to class java.lang.Double
```

{% endtab %}

{% tab title=".NET" %}
L’ `Valeur` attribut est un `dynamique` type Object en interne.

Vous devriez déclarer explicitement le type ; c’est recommandé pour plus de clarté.\
Consultez votre Schéma de données pour savoir quel type déclarer.

```csharp
using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    // textes, dates, classifications ...
    string stringFieldValue = fields["string_field"].SimpleField.Value;

    // un float JSON sera un Double
    Double floatFieldValue = fields["float_field"].SimpleField.Value;

    // même si l'API renvoie toujours un entier, le type sera Double
    Double intFieldValue = fields["int_field"].SimpleField.Value;

    // booléens
    Boolean boolFieldValue = fields["bool_field"].SimpleField.Value;
}
```

Si le mauvais type est déclaré, une exception sera levée, par exemple :

```
RuntimeBinderException : Cannot implicitly convert type 'string' to 'double'
```

{% endtab %}
{% endtabs %}

## `ObjectField` - Champ objet imbriqué

Champ ayant un `champs` attribut qui est une table de hachage (celle de Python `dict`, celui de Java `HashMap`, etc.) de sous-champs.\
Voir la [#fields](#fields "mention") section ci-dessous.

De plus, la `ObjectField` classe possède [#confidence](#confidence "mention") et [#locations](#locations "mention") attributs.

{% tabs %}
{% tab title="Python" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```python
from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields

    object_field = fields.get_object_field("my_object_field")
```

{% endtab %}

{% tab title="Node.js" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

  const objectField = fields.getObjectField("my_object_field");
}
```

{% endtab %}

{% tab title="PHP" %}
En utilisant la `$response` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

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

    $objectField = $fields->getObjectField('my_object_field');
}
```

{% endtab %}

{% tab title="Java" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  ObjectField objectField = fields.getObjectField("my_object_field");
}
```

{% endtab %}

{% tab title=".NET" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```csharp
using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    ObjectField myObjectField = fields["my_object_field"].ObjectField;
}
```

{% endtab %}
{% endtabs %}

### `champs`

Les sous-champs sous forme de type de mappage clé-valeur (Python `dict`, Java `HashMap`, etc.).

L’accès à un sous-champ se fait via son nom dans le Schéma de données.

Chaque sous-champ sera un [#single-value-field-simplefield](#single-value-field-simplefield "mention")ou un [#listfield-list-of-fields](#listfield-list-of-fields "mention").

{% tabs %}
{% tab title="Python" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```python
from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields

    object_field = fields.get_object_field("my_object_field")

    sub_fields: dict = object_field.fields

    # récupérer un seul sous-champ
    subfield_1 = sub_fields["subfield_1"]

    # parcourir les sous-champs
    for field_name, sub_field in sub_fields.items():
        sub_field.value
```

{% endtab %}

{% tab title="Node.js" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

  const objectField = fields.getObjectField("my_object_field");

  const simpleSubFields = objectField.simpleFields;

  // récupérer un seul sous-champ
  const subfield1 = subFields.get("subfield_1");

  // boucle sur les sous-champs simples
  subFields.forEach((simpleSubFields, fieldName) => {
    // Choisissez l'accès approprié :
    // stringValue, numberValue, booleanValue
    const fieldValue = subField.stringValue;
  });

  // Les champs d’objet peuvent aussi avoir des listes :
  const listSubFields = objectField.listFields;
}
```

{% endtab %}

{% tab title="PHP" %}
En utilisant la `$response` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

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

    $objectField = $fields->getObjectField('my_object_field');
    $subFields = $objectField->fields;

    // récupérer un seul sous-champ
    $subfield1 = $subFields->getSimpleField('subfield_1');

    // parcourir les sous-champs
    foreach ($subFields as $fieldName => $subField) {
        $fieldValue = $subField->value;
    }
}
```

{% endtab %}

{% tab title="Ruby" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```ruby
def handle_response(response)
  fields = response.inference.result.fields

  object_field = fields.get_object_field('my_object_field')
  sub_fields = object_field.fields
  
  # récupérer un seul sous-champ
  sub_field_value = sub_fields.get_simple_field('sub_field').value
  
  # parcourir les sous-champs
  sub_fields.each_value do |sub_field|
    field_value = sub_field.value
  end
end
```

{% endtab %}

{% tab title="Java" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```java
import com.mindee.v2.product.extraction.ExtractionResponse;
import com.mindee.parsing.v2.field.ListField;
import com.mindee.parsing.v2.field.ObjectField;
import com.mindee.parsing.v2.field.SimpleField;

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  ObjectField objectField = fields.getObjectField("my_object_field");

  HashMap<String, SimpleField> subFields = objectField.getSimpleFields();

  // récupérer un seul sous-champ
  SimpleField subfield1 = subFields.get("subfield_1");

  // parcourir les sous-champs
  for (Map.Entry<String, SimpleField> entry : subFields.entrySet()) {
    String fieldName = entry.getKey();
    SimpleField subField = entry.getValue();
    
    // Choisissez la méthode d'accès au type de valeur appropriée :
    // String, Double, Boolean
    String fieldValue = subField.getStringValue();
  }
}
```

{% endtab %}

{% tab title=".NET" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```csharp
using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    ObjectField objectField = fields["my_object_field"].ObjectField;

    Dictionary<string, SimpleField> subFields = objectField.SimpleFields;

    // récupérer un seul sous-champ
    SimpleField subField1 = subFields["subfield_1"];

    // parcourir les sous-champs
    // Remarque : en C#14, 'field' est un mot-clé réservé, d'où l'utilisation de 'entry'.
    foreach (KeyValuePair<string, SimpleField> entry in subFields)
    {
        string fieldName = entry.Key;
        SimpleField subField = entry.Value;
        
        // traiter le SimpleField ...
    }
}
```

{% endtab %}
{% endtabs %}

## `ListField` - Liste de champs

Champ ayant un `items` attribut qui est une liste de champs.\
Voir la [#items](#items "mention") section ci-dessous.

De plus, la `ListField` classe possède un [#confidence](#confidence "mention") attribut.

{% tabs %}
{% tab title="Python" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```python
from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields

    my_list_field = fields.get_list_field("my_list_field")
```

{% endtab %}

{% tab title="Node.js" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

  const listField = fields.getListField("my_list_field");
}
```

{% endtab %}

{% tab title="PHP" %}
En utilisant la `$response` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

public function handleResponse(ExtractionResponse $response)
{
    $fields = $response->inference->result->fields;
    
    $listField = $fields->getListField('my_list_field');
}
```

{% endtab %}

{% tab title="Java" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  ListField listField = fields.getListField("my_list_field");
}
```

{% endtab %}

{% tab title=".NET" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```csharp
using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    ListField myListField = fields["my_list_field"].ListField;
}
```

{% endtab %}
{% endtabs %}

### `items`

Liste de champs sous forme de tableau de longueur variable (Python `list`, JavaScript `Array`, Java `List`, etc.).

Chaque élément de la liste sera l’un des suivants :

* [#simplefield-single-value-field](#simplefield-single-value-field "mention")
* [#objectfield-nested-object-field](#objectfield-nested-object-field "mention")

Il n’y aura **pas** de mélange des deux types dans une même liste.

#### Liste de `SimpleField`

{% tabs %}
{% tab title="Python" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```python
from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields

    simple_list_field = fields.get_list_field("my_simple_list_field")

    # Parcourir la liste des champs Simple
    for list_item in simple_list_field.items:
        item_value = list_item.value
```

{% endtab %}

{% tab title="Node.js" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

  const simpleListField = fields.getListField("my_simple_list_field");

  const simpleItems = simpleListField.simpleItems;

  // Parcourez la liste des champs Simple
  for (const itemField of simpleItems) {
    // Choisissez l'accès approprié :
    // stringValue, numberValue, booleanValue
    const fieldValue = itemField.stringValue;
  }
}
```

{% endtab %}

{% tab title="PHP" %}
En utilisant la `$response` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

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

    $simpleListField = $fields->getListField('my_simple_list_field');

    // accéder à une valeur à une position donnée
    $fieldFirstValue = $simpleListField->items[0]->value;

    // Parcourir la liste des champs Simple
    foreach ($simpleListField->items as $listItem) {
        $itemValue = $listItem->value;
    }
}
```

{% endtab %}

{% tab title="Ruby" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```ruby
def handle_response(response)
  fields = response.inference.result.fields
  
  my_list_field = fields.get_list_field('my_simple_list_field')

  # accéder à une valeur à une position donnée
  simple_list_field = my_list_field.simple_items[0].value

  # Parcourir la liste des champs Simple
  simple_list_field.simple_items.each do |list_item|
    item_value = list_item.value
  end
end
```

{% endtab %}

{% tab title="Java" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```java
import com.mindee.v2.product.extraction.ExtractionResponse;
import com.mindee.parsing.v2.field.ListField;
import com.mindee.parsing.v2.field.SimpleField;

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  ListField simpleListField = fields.getListField("my_simple_list_field");

  List<SimpleField> simpleItems = simpleListField.getSimpleItems();

  // Parcourir la liste des champs Simple
  for (SimpleField itemField : simpleItems) {
    // Choisissez la méthode d'accès au type de valeur appropriée :
    // String, Double, Boolean
    String fieldValue = itemField.getStringValue();
  }
}
```

{% endtab %}

{% tab title=".NET" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```csharp
using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    ListField simpleListField = fields["my_simple_list_field"].ListField;

    List<SimpleField> simpleItems = simpleListField.SimpleItems;

    // Parcourez la liste des champs Simple
    foreach (SimpleField itemField in simpleItems)
    {
        // Choisissez le type de valeur approprié :
        // string, Double, Boolean
        string fieldValue = itemField.Value;
    }
}
```

{% endtab %}
{% endtabs %}

#### Liste de `ObjectField`

{% tabs %}
{% tab title="Python" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```python
from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields

    object_list_field = fields.get_list_field("my_object_list_field")

    # Parcourez la liste des champs d'objet
    for object_item in object_list_field.items:
        # récupérez un seul sous-champ
        sub_field_value = object_item.fields["sub_field"].value
        
        # parcourez les sous-champs
        for field_name, sub_field in object_item.fields.items():
            sub_field.value
```

{% endtab %}

{% tab title="Node.js" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

  const fieldObjectList = fields.getListField("my_object_list_field");

  const objectItems = fieldSimpleList.objectItems;

  // Parcourir la liste des champs Object
  for (const itemField of objectItems) {
    const simpleSubFields = itemField.simpleFields;

    // récupérer un seul sous-champ
    const subField1 = subFields.get("subfield_1");

    // Choisissez l'accès approprié :
    // stringValue, numberValue, booleanValue
    const subFieldValue = subField1.stringValue;

    // boucle sur les sous-champs simples
    simpleSubFields.forEach((subField, fieldName) => {
      // Choisissez l'accès approprié :
      // stringValue, numberValue, booleanValue
      const fieldValue = subField.stringValue;
    });

    // Les champs d’objet peuvent aussi avoir des listes :
    const listSubFields = itemField.listFields;
  }
}
```

{% endtab %}

{% tab title="PHP" %}
En utilisant la `$response` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

public function handleResponse(ExtractionResponse $response)
{
    $fields = $response->inference->result->fields;
    $fieldObjectList = $fields->getObjectField('my_object_list_field');

    // accéder à un objet à une position donnée
    $objectItem0 = $fieldObjectList->items[0];
    $subField0Value = $objectItem0->fields->get('sub_field')->value;

    // Parcourez la liste des champs Object
    foreach ($myObjectListField->items as $objectItem) {
        $subFieldValue = $objectItem->fields->get('sub_field')->value;
    }
}
```

{% endtab %}

{% tab title="Ruby" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```ruby
def handle_response(response)
  fields = response.inference.result.fields
  
  object_list_field = fields.get_list_field('my_object_list_field')

  # accéder à un objet à une position donnée
  object_item_0 = object_list_field.items[0]
  sub_field_0_value = object_item_0.fields.get('sub_field').value

  # Parcourir la liste des champs de l'objet
  object_list_field.fields.each do |object_item|
    sub_field_value = object_item.fields.get('sub_field').value
  end
end
```

{% endtab %}

{% tab title="Java" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```java
import com.mindee.v2.product.extraction.ExtractionResponse;
import com.mindee.parsing.v2.field.ListField;
import com.mindee.parsing.v2.field.ObjectField;
import com.mindee.parsing.v2.field.SimpleField;

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  ListField fieldObjectList = fields.getListField("my_object_list_field");

  List<ObjectField> objectItems = listField.getObjectItems();

  // Parcourez la liste des champs Object
  for (ObjectField itemField : objectItems) {

    // Les sous-champs Object seront toujours des champs Simple
    HashMap<String, SimpleField> subFields = itemField.getSimpleFields();

    // récupérer un seul sous-champ
    SimpleField subfield1 = subFields.get("subfield_1");
    
    // Choisissez la méthode d'accès au type de valeur appropriée :
    // String, Double, Boolean
    String subFieldValue = subfield1.getStringValue();

    // parcourir les sous-champs
    for (Map.Entry<String, SimpleField> entry : subFields.entrySet()) {
      String fieldName = entry.getKey();
      SimpleField subField = entry.getValue();
    }
  }
}
```

{% endtab %}

{% tab title=".NET" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```csharp
using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    ListField fieldObjectList = fields["my_simple_list_field"].ListField;

    List<ObjectField> objectItems = fieldObjectList.ObjectItems;

    // Parcourir la liste des champs Object
    foreach (ObjectField itemField in objectItems)
    {
        Dictionary<string, SimpleField> subFields = objectField.SimpleFields;
    
        // récupérer un seul sous-champ
        SimpleField subField1 = subFields["subfield_1"];
        
        // Choisissez le type de valeur approprié :
        // string, Double, Boolean
        string subFieldValue = subField1.Value;
    
        // parcourir les sous-champs
        // Remarque : en C#14, 'field' est un mot-clé réservé, d'où l'utilisation de 'entry'.
        foreach (KeyValuePair<string, SimpleField> entry in subFields)
        {
            string fieldName = entry.Key;
            SimpleField subField = entry.Value;
        }
    }
}
```

{% endtab %}
{% endtabs %}

## Attributs de champ optionnels

Ces attributs de champ ne sont renseignés que lorsque leurs fonctionnalités respectives sont activées.

Les attributs sont toujours présents même lorsqu’ils ne sont pas activés.

### `confidence`

Le niveau de confiance de la valeur extraite.

Les données ne sont renseignées que si la [Score de confiance et exactitude améliorée](/v2/fr/modeles-extraction/optional-features/automation-confidence-score.md) fonctionnalité est activée.

La propriété d’instance est toujours présente ; toutefois, si la fonctionnalité n’est pas activée, elle sera toujours vide (le type exact dépend du langage utilisé : `null`, `undefined`, `None`, etc)

La valeur de l’attribut sera l’un des suivants : `Certain`, `High`, `Medium`, `Low` .\
Le type d’énumération adapté au langage sera disponible pour votre commodité, mappé à partir d’une valeur de chaîne.

{% tabs %}
{% tab title="Python" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```python
from mindee.v2 import ExtractionResponse
from mindee.v2.parsing.field import FieldConfidence

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields

    confidence = fields.get_simple_field("my_simple_field").confidence

    # comparer en utilisant l’énumération `FieldConfidence`
    is_certain = confidence == FieldConfidence.CERTAIN
    is_lte_medium = confidence <= FieldConfidence.MEDIUM
    is_gte_low = confidence >= FieldConfidence.LOW
```

{% endtab %}

{% tab title="Node.js" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

  const confidence = fields.getSimpleField("my_simple_field")?.confidence

  // comparer en utilisant l’énumération `FieldConfidence`
  const isCertain = confidence === FieldConfidence.Certain;
  const isLteMedium = FieldConfidence.lessThanOrEqual(
    confidence, FieldConfidence.Medium
  );
  const isGteLow = FieldConfidence.greaterThanOrEqual(
    confidence, FieldConfidence.Low
  );
}
```

{% endtab %}

{% tab title="PHP" %}
En utilisant la `$response` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```php
use Mindee\V2\Product\Extraction\ExtractionResponse;
use Mindee\Parsing\V2\Field\FieldConfidence;

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

    $confidence = $fields->get('my_simple_field')->confidence;

    // comparer en utilisant l’énumération `FieldConfidence`
    $isCertain = $confidence === FieldConfidence::Certain;
    $isLteMedium = $confidence->lessThanOrEqual(FieldConfidence::Medium);
    $isGteLow = $confidence->greaterThanOrEqual(FieldConfidence::Low);
}
```

{% endtab %}

{% tab title="Ruby" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```ruby
def handle_response(response)
  fields = response.inference.result.fields

  confidence = fields["my_simple_field"].confidence

  # comparer en utilisant la classe `FieldConfidence`
  FieldConfidence = Mindee::Parsing::V2::Field::FieldConfidence
  
  is_certain = confidence == FieldConfidence.CERTAIN
  is_lte_medium = confidence <= FieldConfidence.MEDIUM
  is_gte_low = confidence >= FieldConfidence.LOW
end
```

{% endtab %}

{% tab title="Java" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  // choisissez la méthode d’accesseur de type de champ appropriée : Simple, Object, List
  FieldConfidence confidence = fields.getSimpleField("my_simple_field")
      .getConfidence();

  // comparer en utilisant l’énumération `FieldConfidence`
  boolean isCertain = confidence === FieldConfidence.Certain;
  boolean isLteMedium = confidence.lessThanOrEqual(FieldConfidence.Medium);
  boolean isGteLow = confidence.greaterThanOrEqual(FieldConfidence.Low);
}
```

{% endtab %}

{% tab title=".NET" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```csharp
using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    // énumération nullable, car la présence dépend de l’activation de la fonctionnalité
    FieldConfidence? confidence = fields["my_simple_field"]
        .SimpleField.Confidence;

    // comparer en utilisant l’énumération `FieldConfidence`
    bool isCertain = confidence == FieldConfidence.Certain;
    // convertir en int pour les inégalités relatives
    bool isLteMedium = (int?)confidence <= (int)FieldConfidence.Medium;
    bool isGteLow = (int?)confidence >= (int)FieldConfidence.Low;
}
```

{% endtab %}
{% endtabs %}

### `locations`

Une liste des emplacements du champ sur le document.

Les données ne sont renseignées que si la [Polygones (boîtes englobantes)](/v2/fr/modeles-extraction/optional-features/polygons-bounding-boxes.md) fonctionnalité est activée.

Il est possible qu’un seul champ ait plusieurs emplacements, par exemple lorsqu’un élément de facture s’étend sur deux pages.

Chaque emplacement possède un index de page et un Polygon.

Les index de page commencent à 0, donc la première page est `0`.

Une classe Polygon contient une liste de Points ; l’implémentation spécifique dépendra du langage.

Les Points sont listés dans l’ordre horaire, où l’indice `0` correspond au coin supérieur gauche.

Les coordonnées X,Y des Points sont des flottants normalisés de 0,0 à 1,0, relativement aux dimensions de la page.

{% tabs %}
{% tab title="Python" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```python
from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields
    
    locations = fields.get_simple_field("my_simple_field").locations

    # accès au polygone
    polygon = locations[0].polygon

    # accès aux points : la classe Polygon étend List[Point]
    top_x = polygon[0].x

    # syntaxe alternative, puisque la classe Point étend List<float>
    # top_x = polygon[0][0]

    # des fonctions géométriques sont disponibles dans la classe Polygon
    center = polygon.centroid

    # accès à l’index de page sur lequel se trouve le polygone
    page_index = locations[0].page
```

{% endtab %}

{% tab title="Node.js" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

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

  const locations = fields.getSimpleField("my_simple_field")?.locations;

  // accès au polygone
  const polygon = locations![0].polygon!;

  // accès aux points : la classe Polygon étend Array<Point>
  const topX = polygon[0][0];

  // des fonctions géométriques sont disponibles dans la classe Polygon
  const center = polygon.getCentroid();

  // accès à l’index de page sur lequel se trouve le polygone
  const pageIndex = locations![0].page!;
}
```

{% endtab %}

{% tab title="PHP" %}
En utilisant la `$response` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```php
use Mindee\V2\Product\Extraction\ExtractionResponse;
use Mindee\Parsing\V2\Field\FieldConfidence;

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

    $locations = $fields->get('my_simple_field')->locations;

    // accès au polygone
    $polygon = $locations[0]->polygon;
    
    // accès aux points :
    $points = $polygon->coordinates;
    $topX = $points[0]->getX();
    // syntaxe alternative, puisque la classe Point étend Array<float>
    // $topX = $points[0][0]

    // des fonctions géométriques sont disponibles dans la classe Polygon
    $center = $polygon->getCentroid();
    
    // accès à l’index de page sur lequel se trouve le polygone
    $pageIndex = $locations[0]->page;
}
```

{% endtab %}

{% tab title="Ruby" %}
En utilisant la `$response` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```ruby
def handle_response(response)
  fields = response.inference.result.fields

  locations = fields.get_simple_field('my_simple_field').locations

  # accès au polygone
  polygon = locations[0].polygon

  # accès aux points :
  top_x = polygon[0].x
  # syntaxe alternative
  # top_x = polygon[0][0]

  # des fonctions géométriques sont disponibles dans la classe Polygon
  center = polygon.centroid

  # accès à l’index de page sur lequel se trouve le polygone
  page_index = locations[0].page
end
```

{% endtab %}

{% tab title="Java" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```java
import com.mindee.geometry.Point;
import com.mindee.geometry.Polygon;
import com.mindee.v2.product.extraction.ExtractionResponse;
import com.mindee.parsing.v2.field.FieldLocation;
import java.util.List;

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  // choisissez la méthode d’accesseur de type de champ appropriée : Simple, Object
  List<FieldLocation> locations = fields.getSimpleField("my_simple_field")
      .getLocations();
  
  // accès au polygone
  Polygon polygon = locations.get(0).getPolygon();

  // accès aux points
  List<Point> points = polygon.getCoordinates();
  double topX = points.get(0).getX();

  // des fonctions géométriques sont disponibles dans la classe Polygon
  Point center = polygon.getCentroid();

  // accès à l’index de page sur lequel se trouve le polygone
  int pageIndex = locations.get(0).getPage();
}
```

{% endtab %}

{% tab title=".NET" %}
En utilisant la `réponse` objet désérialisé provenant soit de la réponse de polling, soit d’une charge utile de webhook.

```csharp
using Mindee.V2.Parsing.Inference.Field;
using Mindee.Geometry;

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    List<FieldLocation> locations = fields["my_simple_field"]
        .SimpleField.Locations;

    // accès au polygone
    Polygon polygon = locations.First().Polygon;

    // accès aux points : la classe Polygon étend List<Point>
    double topX = polygon[0].X;

    // notation alternative, puisque la classe Point étend List<double>
    // double topX = polygon[0][0];

    // des fonctions géométriques sont disponibles dans la classe Polygon
    Point center = polygon.GetCentroid();

    // accès à l’index de page sur lequel se trouve le polygone
    int pageIndex = locations.First().Page;
}
```

{% 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/modeles-extraction/sdk-integration/extraction-result.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.