> 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/quick-start.md).

# Démarrage rapide de l'extraction

## Instructions d'installation

{% tabs %}
{% tab title="Python" %}
Nécessite Python ≥ 3.9. Python ≥ 3.11 est recommandé.

Installez simplement le [package PyPI](https://pypi.org/project/mindee/) avec `pip`:

```sh
pip install -U mindee~=5.1
```

{% endtab %}

{% tab title="Node.js" %}
Nécessite Node.js ≥ 20.1. Node.js ≥ 22 est recommandé.

Installez simplement le [package NPM](https://www.npmjs.com/package/mindee):

```sh
npm install mindee@^5.5.0
```

{% endtab %}

{% tab title="PHP" %}
Nécessite PHP ≥ 8.1. PHP ≥ 8.3 est recommandé.

Installez simplement le [package Packagist](https://packagist.org/packages/mindee/mindee) avec [composer](https://getcomposer.org/):

```sh
php composer.phar require "mindee/mindee:>=3.0"
```

{% endtab %}

{% tab title="Ruby" %}
Nécessite Ruby ≥ 3.2.

Installez simplement le [gem](https://rubygems.org/gems/mindee) avec :

```shell
gem install mindee -v '~> 5.2'
```

{% endtab %}

{% tab title="Java" %}
Nécessite Java ≥ 11. Java ≥ 17 est recommandé.

ID de groupe : `com.mindee.sdk`\
ID d’artefact : `mindee-api-java`\
Version : `5.2.0` ou supérieur

Il existe plusieurs méthodes d'installation, Maven, Gradle, etc. :

[Détails de l'installation](https://central.sonatype.com/artifact/com.mindee.sdk/mindee-api-java)
{% endtab %}

{% tab title=".NET" %}
.NET ≥ 8.0 est recommandé.

Installez simplement le [package NuGet](https://www.nuget.org/packages/Mindee) avec `dotnet add`:

```sh
dotnet add package Mindee --version 4.4
```

{% endtab %}
{% endtabs %}

Vous ne voyez pas de prise en charge pour votre langage ou framework préféré ? [Faites une demande de fonctionnalité !](https://feedback.mindee.com/?b=682f69c9e2404756e7e68d1c)

## Envoyer un fichier et interroger les résultats

Prenez note de l'ID de votre modèle pour l'utiliser dans l'API.

Lorsque vous débutez, nous vous recommandons d'utiliser la méthode d'interrogation, qui sera la plus rapide (à moins que vous n'ayez déjà accès à un serveur Web public).

Voici des exemples de code de base, ils sont autonomes et peuvent être exécutés tels quels :

{% tabs %}
{% tab title="Python" %}
Nécessite Python ≥ 3.10. Python ≥ 3.12 est recommandé.\
Nécessite le [bibliothèque cliente Python Mindee](https://pypi.org/project/mindee/) version **5.1.1** ou supérieure.

{% code lineNumbers="true" %}

```python
from mindee import PathInput
from mindee.v2 import (
    Client,
    ExtractionParameters,
    ExtractionResponse,
)

input_path = "/path/to/the/file.ext"
api_key = "MY_API_KEY"
model_id = "MY_MODEL_ID"

# Initialiser un nouveau client
mindee_client = Client(api_key)

# Définir les paramètres Extraction
model_params = ExtractionParameters(
    # ID du modèle, requis.
    model_id=model_id,

    # Options : définissez `True` ou `False` pour remplacer les valeurs par défaut

    # Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
    rag=None,
    # Extraire le contenu textuel complet du document sous forme de chaînes.
    raw_text=None,
    # Calculer les polygones des cadres englobants pour tous les champs.
    polygon=None,
    # Améliorer la précision et l'exactitude de toutes les extractions.
    # Calculer les scores de confiance pour tous les champs.
    confidence=None,
)

# Charger un fichier depuis le disque
input_source = PathInput(input_path)

# Envoyer pour traitement
response = mindee_client.enqueue_and_get_result(
    ExtractionResponse,
    input_source,
    model_params,
)

# Afficher un bref résumé des données analysées
print(response.inference)

# Accéder aux champs du résultat
fields: dict = response.inference.result.fields
```

{% endcode %}

Consultez également [Résultat d'extraction](https://docs.mindee.com/extraction-models/sdk-integration/extraction-result) documentation.
{% endtab %}

{% tab title="Node.js" %}
Nécessite Node.js ≥ 20.1. Node.js ≥ 22 est recommandé.\
Nécessite le [bibliothèque cliente Node.js Mindee](https://www.npmjs.com/package/mindee/) version **5.5.0** ou supérieure.

{% code lineNumbers="true" %}

```javascript
import * as mindee from "mindee";
// Si vous utilisez CommonJS :
// const mindee = require("mindee");

const apiKey = "MY_API_KEY";
const filePath = "/path/to/the/file.ext";
const modelId = "MY_MODEL_ID";

// Initialiser un nouveau client
const mindeeClient = new mindee.Client(
  { apiKey: apiKey }
);

// Définir les paramètres d'Extraction
const modelParams = {
  modelId: modelId,

  // Options : définissez sur `true` ou `false` pour remplacer les valeurs par défaut

  // Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
  rag: undefined,
  // Extraire le contenu textuel complet du document sous forme de chaînes.
  rawText: undefined,
  // Calculer les polygones des boîtes englobantes pour tous les champs.
  polygon: undefined,
  // Améliorez la précision et l'exactitude de toutes les extractions.
  // Calculer les scores de confiance pour tous les champs.
  confidence: undefined,
};

// Charger un fichier depuis le disque
const inputSource = new mindee.PathInput({ inputPath: filePath });

// Envoyer pour traitement
const response = await mindeeClient.enqueueAndGetResult(
  mindee.product.Extraction,
  inputSource,
  modelParams,
);

// afficher un résumé sous forme de chaîne
console.log(response.inference.toString());

// Accéder aux champs du résultat
const fields = response.inference.result.fields;
```

{% endcode %}

Consultez également la [Résultats de traitement](https://docs.mindee.com/extraction-models/sdk-integration/extraction-result) documentation.
{% endtab %}

{% tab title="PHP" %}
Nécessite PHP ≥ 8.1. PHP ≥ 8.3 est recommandé.\
Nécessite le [Bibliothèque cliente PHP Mindee](https://packagist.org/packages/mindee/mindee) version **3.0.0** ou supérieure.

{% code lineNumbers="true" %}

```php
<?php

use Mindee\Input\PathInput;
use Mindee\V2\Client;
use Mindee\V2\Product\Extraction\Params\ExtractionParameters;
use Mindee\V2\Product\Extraction\ExtractionResponse;

$apiKey = "MY_API_KEY";
$modelId = "MY_MODEL_ID";
$filePath = "/path/to/the/file.ext";

// Initialiser un nouveau client
$mindeeClient = new Client($apiKey);

// Définir les paramètres d'Extraction
$modelParams = new ExtractionParameters(
    // ID du modèle, requis.
    $modelId,

    // Options : définissez `true` ou `false` pour remplacer les valeurs par défaut

    // Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
    rag: null,
    // Extrayez le contenu textuel complet du document sous forme de chaînes.
    rawText: null,
    // Calculez les polygones de boîte englobante pour tous les champs.
    polygon: null,
    // Améliorez la précision et l'exactitude de toutes les extractions.
    // Calculez les scores de confiance pour tous les champs.
    confidence: null
);

// Charger un fichier depuis le disque
$inputSource = new PathInput($filePath);

// Envoyer pour traitement à l’aide du polling
$response = $mindeeClient->enqueueAndGetResult(
    ExtractionResponse::class,
    $inputSource,
    $modelParams
);

// Afficher un résumé de la réponse
echo strval($response->inference);

// Accédez aux champs extraits
$fields = $response->inference->result->fields;
```

{% endcode %}

Consultez également les [Résultats de traitement](https://docs.mindee.com/extraction-models/sdk-integration/extraction-result) documentation.
{% endtab %}

{% tab title="Ruby" %}
Nécessite Ruby ≥ 3.2.\
Nécessite [bibliothèque cliente Ruby de Mindee](https://rubygems.org/gems/mindee) version **5.2.1** ou supérieure.

{% code lineNumbers="true" %}

```ruby
require 'mindee'
require 'mindee/v2/product'

input_path = '/path/to/the/file.ext'
api_key = 'MY_API_KEY'
model_id = 'MY_MODEL_ID'

# Initialisez un nouveau client
mindee_client = Mindee::V2::Client.new(api_key: api_key)

# Définissez les paramètres du modèle Extraction
model_params = {
    # ID du modèle, obligatoire.
    model_id: model_id,

    # Options : définissez sur `true` ou `false` pour remplacer les valeurs par défaut

    # Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
    rag: nil,
    # Extrayez le contenu textuel complet du document sous forme de chaînes de caractères.
    raw_text: nil,
    # Calculez les polygones des boîtes englobantes pour tous les champs.
    polygon: nil,
    # Renforcez la précision et l'exactitude de toutes les extractions.
    # Calculez les scores de confiance pour tous les champs.
    confidence: nil
}

# Chargez un fichier depuis le disque
input_source = Mindee::Input::Source::PathInputSource.new(input_path)

# Envoyez pour traitement
response = mindee_client.enqueue_and_get_result(
    Mindee::V2::Product::Extraction::Extraction,
    input_source,
    model_params
)

# Affichez un bref résumé des données analysées
puts response.inference

# Accédez aux champs du résultat
fields = response.inference.result.fields

# fields.get_simple_field('my_simple_field')
# fields.get_list_field('my_list_field')
# fields.get_object_field('my_object_field')
```

{% endcode %}

Consultez également les [Résultats de traitement](https://docs.mindee.com/extraction-models/sdk-integration/extraction-result) documentation.
{% endtab %}

{% tab title="Java" %}
Nécessite Java ≥ 11. Java ≥ 21 est recommandé.\
Nécessite le [SDK Java Mindee](https://central.sonatype.com/artifact/com.mindee.sdk/mindee-api-java) version **5.2.0** ou supérieure.

{% code lineNumbers="true" %}

```java
import com.mindee.input.LocalInputSource;
import com.mindee.v2.MindeeClient;
import com.mindee.v2.product.extraction.params.ExtractionParameters;
import com.mindee.v2.product.extraction.ExtractionResponse;
import java.io.IOException;

public class SimpleMindeeClientV2 {

  public static void main(String[] args)
      throws IOException, InterruptedException
  {
    String apiKey = "MY_API_KEY";
    String modelId = "MY_MODEL_ID";
    String filePath = "/path/to/the/file.ext";

    // Initialisez un nouveau client
    var mindeeClient = new MindeeClient(apiKey);

    // Définissez les paramètres d’Extraction
    var modelParams = ExtractionParameters
        // ID du modèle, requis.
        .builder(modelId)

        // Options : définissez à `true` ou `false` pour remplacer les valeurs par défaut

        // Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
        .rag(null)
        // Extrayez le contenu textuel complet du document sous forme de chaînes.
        .rawText(null)
        // Calculez les polygones de boîte englobante pour tous les champs.
        .polygon(null)
        // Améliorez la précision et l’exactitude de toutes les extractions.
        // Calculez les scores de confiance pour tous les champs.
        .confidence(null)

        .build();

    // Chargez un fichier depuis le disque
    var inputSource = new LocalInputSource(filePath);

    // Envoyez pour traitement en mode polling
    ExtractionResponse response = mindeeClient.enqueueAndGetResult(
        ExtractionResponse.class,
        inputSource,
        modelParams
    );

    // Affichez un résumé de la réponse
    System.out.println(response.getInference().toString());

    // Accédez aux champs du résultat
    var fields = response.getInference().getResult().getFields();
  }
}
```

{% endcode %}

Consultez également la [Résultats du traitement](https://docs.mindee.com/extraction-models/sdk-integration/extraction-result) documentation.
{% endtab %}

{% tab title=".NET" %}
.NET ≥ 8.0 est recommandé.\
Nécessite le [Bibliothèque cliente .NET Mindee](https://www.nuget.org/packages/Mindee) version **4.3.0** ou supérieure.

{% code lineNumbers="true" %}

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

string filePath = "/path/to/the/file.ext";
string apiKey = "MY_API_KEY";
string modelId = "MY_MODEL_ID";

// Créez un nouveau client
Client mindeeClient = new Client(apiKey);

// Définir les paramètres d'Extraction
var modelParams = new ExtractionParameters(
    modelId: modelId

    // Options : définissez `true` ou `false` pour remplacer les valeurs par défaut

    // Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
    , rag: null
    // Extrayez le contenu textuel complet du document sous forme de chaînes.
    , rawText: null
    // Calculez les polygones de boîte englobante pour tous les champs.
    , polygon: null
    // Améliorez la précision et l'exactitude de toutes les extractions.
    // Calculez les scores de confiance pour tous les champs.
    , confidence: null
);

// Charger un fichier depuis le disque
var inputSource = new LocalInputSource(filePath);

// Téléversez le fichier
var response = await mindeeClient.EnqueueAndGetResultAsync<ExtractionResponse>(
    inputSource, modelParams);

// Afficher un résumé de la réponse
System.Console.WriteLine(response.Inference.ToString());

// Accéder aux champs extraits
var fields = response.Inference.Result.Fields;
```

{% endcode %}

Consultez également les [Résultats de traitement](https://docs.mindee.com/extraction-models/sdk-integration/extraction-result) documentation.
{% endtab %}
{% endtabs %}

### Détails sur l'envoi

Pour plus de détails sur les options disponibles et l'utilisation avancée, consultez les sections suivantes :

* [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md)
* [Charger et ajuster un fichier](/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md)
* [Charger une URL](/v2/fr/integrations/client-libraries-sdk/load-an-url.md)
* [Envoyer un fichier ou une URL](/v2/fr/integrations/client-libraries-sdk/send-a-file-or-url.md)

## Traiter les résultats d'extraction

Une fois que vous avez envoyé le fichier et récupéré la réponse, vous pouvez commencer à accéder aux résultats.

Les champs du modèle d'extraction se trouveront dans le `attribut fields` objet dans la valeur renvoyée (la `response` variable renvoyée à l'étape ci-dessus).

Chaque clé dans le `attribut fields` objet correspond au champ `nom` dans votre Schéma de données.

Vous devrez adapter votre traitement en fonction du [type de champ](/v2/fr/modeles-extraction/data-schema.md#field-types), par exemple lors de l'itération sur des listes ou de l'accès à des sous-champs.

{% tabs %}
{% tab title="Python" %}
Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Vous pouvez (et devriez !) préciser le type de valeur ; les types possibles sont `str` , `bool` , `float` .\
Notez que tous les types peuvent être `None`.

```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
```

Accéder à une liste de valeurs simples, où `my_list_field` est le nom du champ dans le modèle.

```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
```

Accéder à un champ objet et à ses sous-champs, où `my_object_field` est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé `subfield_1` .

```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
```

Accéder à une liste d'objets, où `my_object_list_field` est le nom du champ dans le modèle.

```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" %}
Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Accédez aux champs en tant que `SimpleField` instances lors de la récupération de leur valeur.

```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;
}
```

Accéder à une liste de valeurs, où `my_simple_list_field` est le nom du champ dans le modèle.

Nous devons préciser que le champ est un `ListField` afin d'accéder à ses éléments.

```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;
  }
}
```

Accéder à un champ objet et à ses sous-champs, où `my_object_field` est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé `subfield_1` .

```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;
}
```

Accéder à une liste d'objets, où `my_object_list_field` est le nom du champ dans le modèle.

Nous devons préciser que le champ est un `ListField` afin d'accéder à ses éléments.

```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" %}
Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Accédez aux champs en tant que `SimpleField` instances lors de la récupération de leur valeur.

```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;
}
```

Accéder à une liste de valeurs, où `my_simple_list_field` est le nom du champ dans le modèle.

Nous devons préciser que le champ est un `ListField` afin d'accéder à ses éléments.

```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;
    }
}
```

Accéder à un champ objet et à ses sous-champs, où `my_object_field` est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé `subfield_1` .

```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;
    }
}
```

Accéder à une liste d'objets, où `my_object_list_field` est le nom du champ dans le modèle.

Nous devons préciser que le champ est un `ListField` afin d'accéder à ses éléments.

```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" %}
Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Accédez aux champs en tant que `SimpleField` instances lors de la récupération de leur valeur.

```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
```

Accéder à une liste de valeurs, où `my_simple_list_field` est le nom du champ dans le modèle.

Accédez à la liste en tant que `ListField` instance, et les éléments en tant que `SimpleField` instances.

```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
```

Accéder à un champ objet et à ses sous-champs, où `my_object_field` est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé `subfield_1` .

```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
```

Accéder à une liste d'objets, où `my_object_list_field` est le nom du champ dans le modèle.

Accédez à la liste en tant que `ListField` instance, et les éléments en tant que `ObjectField` instances.

```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
```

{% hint style="info" %}
Vous pouvez techniquement accéder à tous les types de champs par leur indice : `fields['field_name']`

Ceci est fortement déconseillé et **non pris en charge**.
{% endhint %}
{% endtab %}

{% tab title="Java" %}
Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Accédez aux champs en tant que `SimpleField` instances lors de la récupération de leur valeur.

Nous devons également préciser le type de valeur ; les types possibles sont `String` , `Booléen` , `Double` .\
Notez que tous les types peuvent être `null`.

```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();
}
```

Accéder à une liste de valeurs simples, où `my_simple_list_field` est le nom du champ dans le modèle.

Nous devons préciser que le champ est un `ListField` afin d'accéder à ses `SimpleItems`.

Pour chaque élément de la liste, nous devons également préciser le champ et le type de valeur corrects, comme décrit ci-dessus.

```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();
  }
}
```

Accéder à un champ objet et à ses sous-champs, où `my_object_field` est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé `subfield_1` .

```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();
  }
}
```

Accéder à une liste d'objets, où `my_object_list_field` est le nom du champ dans le modèle.

```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();
    }
  }
}
```

Selon vos besoins, cela peut être simplifié à l'aide de diverses méthodes personnalisées.
{% endtab %}

{% tab title=".NET" %}
Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Accédez aux champs en tant que `SimpleField` instances lors de la récupération de leur valeur.

Nous devons également préciser le type de valeur ; les types possibles sont `string` , `Booléen` , `Double` .\
Notez que tous les types peuvent être `null`.

```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;
}
```

Accéder à une liste de valeurs simples, où `my_list_field` est le nom du champ dans le modèle.

Nous devons préciser que le champ est un `ListField` afin d'accéder à ses `SimpleItems`.

```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;
    }
}
```

Accéder à un champ objet et à ses sous-champs, où `my_object_field` est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé `subfield_1` .

```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 ...
    }
}
```

Accéder à une liste d'objets, où `my_object_list_field` est le nom du champ dans le modèle.

```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 %}

### Détails sur le traitement de la réponse

Pour plus de détails sur l'utilisation des champs de résultat dans votre application : [Résultat de l'extraction](/v2/fr/modeles-extraction/sdk-integration/extraction-result.md)

Pour plus de détails sur les métadonnées de réponse : [Traitement des réponses](/v2/fr/integrations/client-libraries-sdk/process-the-response.md)


---

# 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/quick-start.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.