> 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 de l'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ès aux champs du Schéma de données

Les champs sont totalement 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 (dict de Python `dict`, 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 valeur unique, `SimpleField` class.
* Un objet imbriqué (sous-champs), `ObjectField` class.
* Une liste ou un tableau de champs, `ListField` class.

## `SimpleField` - Champ à valeur unique

Type de champ de base possédant l'attribut `value` .\
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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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 la donnée extraite.\
Types possibles : string, numeric, boolean.\
Tous les types peuvent être null.

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

Pour les valeurs numériques, l'API renvoie toujours `number` types, ce qui signifie qu'il n'y a pas de prise en charge du typage explicite en float ou en integer. Par conséquent, le SDK utilise toujours des types flottants pour les valeurs numériques, si le langage le prend en charge. Cela garantit un typage cohérent dans le SDK sans perte d'information.

{% tabs %}
{% tab title="Python" %}
Utilisation de 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` sous le capot.

Vous devriez utiliser les accesseurs explicitement typés ; 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;
  
  // le type est 'number', pas de distinction entre les flottants 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" %}
Utilisation de 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" %}
Utilisation de 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` sous le capot.

Vous devrez déclarer explicitement le type, sinon le code ne 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` sous le capot.

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 d'objet imbriqué

Champ possédant un attribut `fields` qui est une table de hachage (dict de Python `dict`, 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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 %}

### `fields`

Les sous-champs sous forme 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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 possédant un attribut `items` qui est une liste de champs.\
Voir la [#items](#items "mention") section ci-dessous.

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

{% tabs %}
{% tab title="Python" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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 la même liste.

#### Liste de `SimpleField`

{% tabs %}
{% tab title="Python" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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" %}
Utilisation de 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 facultatifs des champs

Ces attributs de champ ne sont remplis 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 remplies 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 éléments 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" %}
Utilisation de 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 à l'aide de 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" %}
Utilisation de 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 à l'aide de 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" %}
Utilisation de 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 à l'aide de l'énumération `FieldConfidence`
    $isCertain = $confidence === FieldConfidence::Certain;
    $isLteMedium = $confidence->lessThanOrEqual(FieldConfidence::Medium);
    $isGteLow = $confidence->greaterThanOrEqual(FieldConfidence::Low);
}
```

{% endtab %}

{% tab title="Ruby" %}
Utilisation de 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 à l'aide de 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" %}
Utilisation de 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'accès au type de champ appropriée : Simple, Object, List
  FieldConfidence confidence = fields.getSimpleField("my_simple_field")
      .getConfidence();

  // comparer à l'aide de 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" %}
Utilisation de 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 à l'aide de 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 remplies 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 a 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` est en haut à gauche.

Les coordonnées X,Y du Point sont des flottants normalisés de 0.0 à 1.0, relatifs aux dimensions de la page.

{% tabs %}
{% tab title="Python" %}
Utilisation de 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 de géométrie sont disponibles dans la classe Polygon
    center = polygon.centroid

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

{% endtab %}

{% tab title="Node.js" %}
Utilisation de 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 de géométrie sont disponibles dans la classe Polygon
  const center = polygon.getCentroid();

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

{% endtab %}

{% tab title="PHP" %}
Utilisation de 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 de géométrie sont disponibles dans la classe Polygon
    $center = $polygon->getCentroid();
    
    // accès à l'index de la page sur laquelle se trouve le polygone
    $pageIndex = $locations[0]->page;
}
```

{% endtab %}

{% tab title="Ruby" %}
Utilisation de 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 de géométrie sont disponibles dans la classe Polygon
  center = polygon.centroid

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

{% endtab %}

{% tab title="Java" %}
Utilisation de 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'accès au 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 de géométrie sont disponibles dans la classe Polygon
  Point center = polygon.getCentroid();

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

{% endtab %}

{% tab title=".NET" %}
Utilisation de 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 de géométrie sont disponibles dans la classe Polygon
    Point center = polygon.GetCentroid();

    // accès à l'index de la page sur laquelle 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.