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

# Envoyer un fichier ou une URL

Documentation de référence sur l’envoi de fichiers ou d’URL pour traitement à l’aide des bibliothèques clientes Mindee.

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

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

Vous cherchez des exemples de code complets ?

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

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

## Exigences

Vous devrez avoir votre client Mindee correctement configuré comme décrit dans la [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md) section.

Vous pouvez envoyer soit un fichier local, soit une URL aux serveurs Mindee pour traitement.

Il n'y a aucune différence entre l'envoi d'un fichier ou d'une URL ; les deux sont considérés comme des sources d'entrée valides.

### Utilisation d'un fichier local

Vous aurez besoin d'une source d'entrée locale comme décrit dans la [Charger et ajuster un fichier](/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md) section.

Un fichier local peut être manipulé et ajusté avant l'envoi, comme décrit dans la [Charger et ajuster un fichier](/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md#adjust-the-source-file) section.

### Utilisation d'une URL

Vous aurez besoin d'une source d'entrée URL comme décrit dans la [Charger une URL](/v2/fr/integrations/client-libraries-sdk/load-an-url.md) section.

Le contenu d'une URL **ne peut pas** être manipulé localement.\
Vous devrez le télécharger sur la machine locale si vous souhaitez ajuster le fichier d'une quelconque manière avant l'envoi.

## Envoi avec interrogation

Envoyer un document en utilisant [l'interrogation](/v2/fr/integrations/polling-for-results.md), c'est la méthode la plus simple pour commencer.

La bibliothèque cliente effectuera le POST de la requête pour vous, puis interrogera automatiquement l'API.

### Configuration de l'interrogation

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

{% tabs %}
{% tab title="Python" %}
Lors de l'interrogation, vous n'avez vraiment besoin de définir que le `model_id` .

```python
model_params = ExtractionParameters(model_id="MY_MODEL_ID")
```

Vous pouvez également ajuster les différents paramètres d'interrogation ; définissez ces options si vous rencontrez des problèmes de délai d'attente.

```python
from mindee import PollingOptions

polling_options=PollingOptions(
    # Délai initial avant la première tentative d'interrogation.
    initial_delay_sec=3,
    # Délai entre chaque tentative d'interrogation.
    delay_sec=1.5,
    # Nombre total de tentatives d'interrogation.
    max_retries=80,
)
```

{% endtab %}

{% tab title="Node.js" %}
Lors de l'interrogation, vous n'avez vraiment besoin de définir que le `modelId` .

```typescript
const modelParams = {modelId: "MY_MODEL_ID"};
```

Vous pouvez également ajuster les différents paramètres d'interrogation ; définissez ces options si vous rencontrez des problèmes de délai d'attente. Vous devez ensuite transmettre la configuration à l'appel de la méthode d'interrogation.

```typescript
const pollingOptions = {
  // Délai initial avant la première tentative d'interrogation.
  initialDelaySec: 3.0,
  // Délai entre chaque tentative d'interrogation.
  delaySec: 1.5,
  // Nombre total de tentatives d'interrogation.
  maxRetries: 80,
}
```

{% endtab %}

{% tab title="PHP" %}
Lors de l'interrogation, vous n'avez vraiment besoin de définir que le `modelId` .

```php
$modelParams = new ExtractionParameters(modelId: "MY_MODEL_ID");
```

Vous pouvez également ajuster les différents paramètres d'interrogation ; définissez ces options si vous rencontrez des problèmes de délai d'attente. Vous devez ensuite transmettre la configuration à l'appel de la méthode d'interrogation.

```php
use Mindee\\ClientOptions\\PollingOptions;

$pollingOptions = new PollingOptions(
    // Délai initial avant la première tentative d'interrogation.
    initialDelaySec: 3.0,
    // Délai entre chaque tentative d'interrogation.
    delaySec: 1.5,
    // Nombre total de tentatives d'interrogation.
    maxRetries: 80,
);
```

{% endtab %}

{% tab title="Ruby" %}
Lors de l'interrogation, vous n'avez vraiment besoin de définir que le `model_id` .

```ruby
model_params = { model_id: "MY_MODEL_ID" }
```

Vous pouvez également ajuster les différents paramètres d'interrogation ; définissez ces options si vous rencontrez des problèmes de délai d'attente. Vous devez ensuite transmettre la configuration à l'appel de la méthode d'interrogation.

```ruby
polling_options = {
  # Délai initial avant la première tentative d'interrogation.
  initial_delay_sec: 3,
  # Délai entre chaque tentative d'interrogation.
  delay_sec: 1.5,
  # Nombre total de tentatives d'interrogation.
  max_retries: 80,
}
```

{% endtab %}

{% tab title="Java" %}
Lors de l'interrogation, vous n'avez vraiment besoin de définir que le `modelId` .

```java
var modelParams = ExtractionParameters
        .builder("MY_MODEL_ID")
        .build();
```

Vous pouvez également ajuster les différents paramètres d'interrogation ; définissez ces options si vous rencontrez des problèmes de délai d'attente. Vous devez ensuite transmettre la configuration à l'appel de la méthode d'interrogation.

```java
import com.mindee.v2.clientoptions.PollingOptions;

var pollingOptions = PollingOptions
    .builder()
    // Délai initial avant la première tentative d'interrogation.
    .initialDelaySec(3.0)
    // Délai entre chaque tentative d'interrogation.
    .intervalSec(1.5)
    // Nombre total de tentatives d'interrogation.
    .maxRetries(80)
    // compléter le générateur d'interrogation
    .build();
```

{% endtab %}

{% tab title=".NET" %}
Lors de l'interrogation, vous n'avez vraiment besoin de définir que le `modelId`.

```csharp
var modelParams = new ExtractionParameters(modelId: "MY_MODEL_ID");
```

Vous pouvez également ajuster les différents paramètres d'interrogation ; définissez ces options si vous rencontrez des problèmes de délai d'attente. Vous devez ensuite transmettre la configuration à l'appel de la méthode d'interrogation.

```csharp
using Mindee.V2.ClientOptions;

var pollingOptions = new PollingOptions(
    // Délai initial avant la première tentative d'interrogation.
    initialDelaySec: 3.5,
    // Délai entre chaque tentative d'interrogation.
    intervalSec: 1.5,
    // Nombre total de tentatives d'interrogation.
    maxRetries: 80
);
```

{% endtab %}
{% endtabs %}

### Appel de la méthode d'interrogation

Vous aurez besoin d’une source valide *source d’entrée*, parmi les suivantes :

* une source locale créée dans [Charger et ajuster un fichier](/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md)
* une source distante créée dans [Charger une URL](/v2/fr/integrations/client-libraries-sdk/load-an-url.md)

{% tabs %}
{% tab title="Python" %}
Le `mindee_client`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

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

```python
response = mindee_client.enqueue_and_get_result(
    # Utilisez la classe de produit appropriée
    ExtractionResponse,
    input_source,
    model_params,
)

# Pour tester facilement quelles données ont été extraites,
# affichez simplement une représentation RST de l'inférence
print(response.inference)
```

{% endtab %}

{% tab title="Node.js" %}
Le `mindeeClient`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

Utilisez la `enqueueAndGetResult` méthode. N'oubliez pas d'utiliser la classe Product/Model appropriée, les exemples utilisent `Extraction`.

```typescript
const response = mindeeClient.enqueueAndGetResult(
  // Utilisez la classe de produit appropriée
  mindee.product.Extraction,
  inputSource,
  modelParams,
  // facultatif, à définir en cas de problèmes de délai d'attente
  // pollingOptions,
);

// Gérer la promesse de réponse
response.then((resp) => {
  // Pour tester facilement quelles données ont été extraites,
  // affichez simplement une représentation RST de l'inférence
  console.log(resp.inference.toString());
});
```

{% endtab %}

{% tab title="PHP" %}
Le `$mindeeClient` , créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

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

```php
$response = $mindeeClient->enqueueAndGetResult(
    // Utilisez la classe de produit appropriée
    ExtractionResponse::class,
    $inputSource,
    $modelParams,
    // facultatif, à définir en cas de problèmes de délai d'attente
    // $pollingOptions
);

// Pour tester facilement quelles données ont été extraites,
// affichez simplement une représentation RST de l'inférence
echo strval($response->inference);
```

{% endtab %}

{% tab title="Ruby" %}
Le `mindee_client`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

Utilisez la `enqueue_and_get_result` méthode. N'oubliez pas d'utiliser la classe Product/Model appropriée, les exemples utilisent `Extraction`.

```ruby
response = mindee_client.enqueue_and_get_result(
  # Utilisez la classe de produit appropriée
  Mindee::V2::Product::Extraction::Extraction,
  input_source,
  model_params,
  # facultatif, à définir uniquement en cas de problèmes de délai d'attente.
  # polling_options,
)

# Pour tester facilement quelles données ont été extraites,
# affichez simplement une représentation RST de l'inférence
puts response.inference
```

{% endtab %}

{% tab title="Java" %}
Le `mindeeClient`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

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

```java
var response = mindeeClient.enqueueAndGetResult(
    // Utilisez la classe de produit appropriée
    ExtractionResponse.class,
    inputSource,
    modelParams
    // facultatif, à définir en cas de problèmes de délai d'attente
    // pollingOptions
);

// Pour tester facilement quelles données ont été extraites,
// affichez simplement une représentation RST de l'inférence
System.out.println(response.getInference().toString());
```

{% endtab %}

{% tab title=".NET" %}
Le `mindeeClient`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

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

```csharp
var response = await mindeeClient.EnqueueAndGetResultAsync<ExtractionResponse>(
    inputSource
    , modelParams
    // facultatif, à définir en cas de problèmes de délai d'attente
    //, pollingOptions
);

// Pour tester facilement quelles données ont été extraites,
// affichez simplement une représentation RST de l'inférence
System.Console.WriteLine(response.Inference.ToString());
```

{% endtab %}
{% endtabs %}

## Envoi avec webhook

Envoyer un document en utilisant [webhooks](/v2/fr/integrations/webhooks.md), c'est recommandé pour une utilisation en production, en particulier pour les gros volumes.

Vous aurez besoin d’une source valide *source d’entrée*, parmi les suivantes :

* une source locale créée dans [Charger et ajuster un fichier](/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md)
* une source distante créée dans [Charger une URL](/v2/fr/integrations/client-libraries-sdk/load-an-url.md)

### Configuration du webhook

La bibliothèque cliente effectuera le POST de la requête vers votre serveur web, comme configuré par votre point de terminaison webhook.

Pour plus d'informations sur les webhooks, consultez la [Utilisation des webhooks](/v2/fr/integrations/webhooks.md) page.

Lorsque vous utilisez un webhook, vous devrez définir l'ID de modèle et les ID de webhook à utiliser.

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

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

```python
model_params = ExtractionParameters(
    # ID du modèle, obligatoire.
    model_id="MY_MODEL_ID",
    
    # Ajoutez ici autant d'ID de webhook que nécessaire.
    webhook_ids=["ENDPOINT_1_UUID"],
    
    # ... toute autre option ...
)
```

{% endtab %}

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

```typescript
const modelParams = {
  // ID du modèle, obligatoire.
  modelId: "MY_MODEL_ID",

  // Ajoutez ici autant d'ID de webhook que nécessaire.
  webhookIds: ["ENDPOINT_1_UUID"],

  // ... toute autre option ...
};
```

{% endtab %}

{% tab title="PHP" %}

```php
$modelParams = new ExtractionParameters(
    // ID du modèle, obligatoire.
    modelId: "MY_MODEL_ID",
    
    // Ajoutez ici autant d'ID de webhook que nécessaire.
    // Remarque : PHP 8.1 n'autorise le passage que d'un seul ID.
    webhooksIds: array("ENDPOINT_1_UUID"),

    // ... toute autre option ...
);
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
model_params = {
  # ID du modèle, obligatoire.
  model_id: 'MY_MODEL_ID',

  # Ajoutez ici autant d'ID de webhook que nécessaire.
  webhook_ids: ["ENDPOINT_1_UUID"],

  # ... toute autre option ...
}
```

{% endtab %}

{% tab title="Java" %}

```java
var modelParams = ExtractionParameters
    // ID du modèle, obligatoire.
    .builder("MY_MODEL_ID")
    
    // Ajoutez ici autant d'ID de webhook que nécessaire.
    .webhookIds(new String[]{"ENDPOINT_1_UUID"})
    
    // ... toute autre option ...
    
    .build();
```

{% endtab %}

{% tab title=".NET" %}

```csharp
var modelParams = new ExtractionParameters(
    // ID du modèle, obligatoire.
    modelId: "MY_MODEL_ID"
    
    // Ajoutez ici autant d'ID de webhook que nécessaire.
    , webhookIds: new List<string>{ "ENDPOINT_1_UUID" }
    
    // ... toute autre option ...
);
```

{% endtab %}
{% endtabs %}

### Appel de la méthode du webhook

Vous pouvez spécifier autant d'identifiants de point de terminaison webhook que vous le souhaitez ; chacun recevra la charge utile.

{% tabs %}
{% tab title="Python" %}
En utilisant la `mindee_client`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md#initialize-the-mindee-client).

Utilisez la `enqueue_inference` méthode :

```python
response = mindee_client.enqueue(
    input_source, model_params
)

# Vous devez conserver l'ID du job pour vos archives/debogage
print(response.job.id)

# Si vous avez défini un `alias`, vous pouvez vérifier qu'il a bien été pris en compte
print(response.job.alias)
```

**Remarque :** Vous pouvez utiliser les deux méthodes !

Tout d'abord, assurez-vous d'avoir ajouté un ID de webhook à la `ExtractionParameters` instance.\
Puis, appelez `enqueue_and_get_result` .\
Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.
{% endtab %}

{% tab title="Node.js" %}
En utilisant la `mindeeClient`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md#initialize-the-mindee-client).

Utilisez la `enqueue` méthode :

```typescript
const response = await mindeeClient.enqueue(
  mindee.product.Extraction,
  inputSource,
  modelParams
);

// Vous devez conserver l'ID du job pour vos archives/debogage
console.log(response.job.id);

// Si vous avez défini un `alias`, vous pouvez vérifier qu'il a bien été pris en compte
console.log(response.job.alias);
```

**Remarque :** Vous pouvez utiliser les deux méthodes !

Tout d'abord, assurez-vous d'avoir ajouté un ID de webhook à la `modelParams` objet.\
Puis, appelez `enqueueAndGetResult` et `attendez` la promesse.\
Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.
{% endtab %}

{% tab title="PHP" %}
En utilisant la `$mindeeClient`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md#initialize-the-mindee-client).

Utilisez la `enqueueInference` méthode :

```php
$response = $mindeeClient->enqueue(
    $inputSource,
    $modelParams
);

// Vous devez conserver l'ID du job pour vos archives/debogage
echo strval($response->job->id);

// Si vous avez défini un `alias`, vous pouvez vérifier qu'il a bien été pris en compte
echo strval($response->job->alias);
```

**Remarque :** Vous pouvez également utiliser les deux méthodes !

Tout d'abord, assurez-vous d'avoir ajouté un ID de webhook à la `ExtractionParameters` instance.\
Puis, appelez `enqueueAndGetResult`.\
Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.
{% endtab %}

{% tab title="Ruby" %}
En utilisant la `mindee_client`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md#initialize-the-mindee-client).

Utilisez la `enqueue` méthode :

```ruby
response = mindee_client.enqueue(
    Mindee::V2::Product::Extraction::Extraction,
    input_source,
    model_params,
)

# Vous devez conserver l'ID du job pour vos archives/debogage
puts response.job.id

# Si vous avez défini un `alias`, vous pouvez vérifier qu'il a bien été pris en compte
puts response.job.alias
```

**Remarque :** Vous pouvez utiliser les deux méthodes !

Tout d'abord, assurez-vous d'avoir ajouté un ID de webhook à la `inference_params` hash.\
Puis, appelez `enqueue_and_get_result` .\
Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.
{% endtab %}

{% tab title="Java" %}
En utilisant la `mindeeClient`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md#initialize-the-mindee-client).

Utilisez la `enqueueInference` méthode :

```java
JobResponse response = mindeeClient.enqueue(
    inputSource, modelParams
);

// Vous devez conserver l'ID du job pour vos archives/debogage
System.out.println(response.getJob().getId());

// Si vous avez défini un `alias`, vous pouvez vérifier qu'il a bien été pris en compte
System.out.println(response.getJob().getAlias());
```

**Remarque :** Vous pouvez utiliser les deux méthodes !

Tout d'abord, assurez-vous d'avoir ajouté un ID de webhook à la `ExtractionParameters` instance.\
Puis, appelez `enqueueAndGetInference` et gérez la promesse.\
Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.
{% endtab %}

{% tab title=".NET" %}
En utilisant la `mindeeClient`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md#initialize-the-mindee-client).

Utilisez `EnqueueInferenceAsync` méthode :

```csharp
var response = mindeeClient.EnqueueAsync(
    inputSource, modelParams
);

// Vous devez conserver l'ID du job pour vos archives/debogage
System.Console.WriteLine(response.Job.Id);

// Si vous avez défini un `alias`, vous pouvez vérifier qu'il a bien été pris en compte
System.Console.WriteLine(response.Job.Alias);
```

**Remarque :** Vous pouvez également utiliser les deux méthodes !

Tout d'abord, assurez-vous d'avoir ajouté un ID de webhook à la `ExtractionParameters` instance.\
Puis, appelez `EnqueueAndGetResultAsync`.\
Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.
{% endtab %}
{% endtabs %}

## Obtenir l'état de traitement

L'accès aux informations de traitement se fait à l'aide du `objet Job` et des appels de méthode associés.

Si vous utilisez des webhooks, nous vous recommandons vivement de stocker l'ID du job afin de pouvoir récupérer ces informations à des fins de débogage.

Vous pouvez accéder à :

* l'URL du résultat
* l'état global de traitement
* les erreurs détaillées, le cas échéant
* l'état de chaque webhook envoyé
* les dates de création et d'achèvement
* etc.

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

```python
# à partir de la méthode `enqueue` (généralement pour webhook)
job_id = response.job.id

# à partir de la méthode `enqueue_and_get_result` (généralement pour l'interrogation)
# job_id = response.inference.job.id

job_response = mindee_client.get_job(job_id)

# quelques métadonnées, consultez votre IDE pour toutes les attributs disponibles
print(job_response.job.status)
print(job_response.job.created_at)
print(job_response.job.completed_at)

# vérifier les webhooks
for webhook in job_response.job.webhooks:
    print(f"{webhook.id} status: {webhook.status}")
```

{% endtab %}

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

```typescript
// à partir de la méthode `enqueue` (généralement pour webhook)
const jobId = response.job.id;

// à partir de la méthode `enqueueAndGetResult` (généralement pour l'interrogation)
//const jobId = response.inference.job.id;

const jobResponse = await mindeeClient.getJob(jobId);

// quelques métadonnées, consultez votre IDE pour tous les attributs disponibles
console.log(jobResponse.job.status);
console.log(jobResponse.job.createdAt);
console.log(jobResponse.job.completedAt);

// vérifier les webhooks
jobResponse.job.webhooks.forEach((webhook) => {
  console.log(`${webhook.id} status: ${webhook.status}`);
});
```

{% endtab %}

{% tab title="PHP" %}

```php
// à partir de la méthode `enqueueInference` (généralement pour webhook)
$jobId = $response->job->id;

// à partir de la méthode `enqueueAndGetInference` (généralement pour l'interrogation)
// $jobId = $response->inference->job->id;

$jobResponse = $mindeeClient->getJob($jobId);

// quelques métadonnées, consultez votre IDE pour tous les attributs disponibles
echo $jobResponse->job->status;
echo $jobResponse->job->createdAt->format('Y-m-d H:i:s');
echo $jobResponse->job->completedAt?->format('Y-m-d H:i:s');

// vérifier les webhooks
foreach ($jobResponse->job->webhooks as $webhook) {
    echo "{$webhook->id} status: {$webhook->status}";
}
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
# à partir de la méthode `enqueue` (généralement pour webhook)
job_id = response.job.id

# à partir de la méthode `enqueue_and_get_result` (généralement pour l'interrogation)
# job_id = response.inference.job.id

job_response = mindee_client.get_job(job_id)

# quelques métadonnées, consultez votre IDE pour toutes les attributs disponibles
puts job_response.job.status
puts job_response.job.created_at
puts job_response.job.completed_at

# vérifier les webhooks
job_response.job.webhooks.each do |webhook|
  puts "#{webhook.id} status: #{webhook.status}"
end
```

{% endtab %}

{% tab title="Java" %}

```java
// à partir de la méthode `enqueueInference` (généralement pour webhook)
String jobId = response.getJob().getId();

// à partir de la méthode `enqueueAndGetInference` (généralement pour l'interrogation)
// String jobId = response.getInference().getJob().getId();

var jobResponse = mindeeClient.getJob(jobId);

// quelques métadonnées, consultez votre IDE pour tous les attributs disponibles
var job = jobResponse.getJob();
System.out.println(job.getStatus());
System.out.println(job.getCreatedAt());
System.out.println(job.getCompletedAt());

// vérifier les webhooks
job.getWebhooks().forEach(webhook ->
    System.out.println(webhook.getId() + " status: " + webhook.getStatus())
);
```

{% endtab %}

{% tab title=".NET" %}

```csharp
// à partir de la méthode `EnqueueInferenceAsync` (généralement pour webhook)
var jobId = response.Job.Id;

// à partir de la méthode `EnqueueAndGetResultAsync` (généralement pour l'interrogation)
// var jobId = response.Inference.Job.Id;

var jobResponse = await mindeeClient.GetJobAsync(jobId);

// quelques métadonnées, consultez votre IDE pour tous les attributs disponibles
Console.WriteLine(jobResponse.Job.Status);
Console.WriteLine(jobResponse.Job.CreatedAt);
Console.WriteLine(jobResponse.Job.CompletedAt);

// vérifier les webhooks
foreach (var webhook in jobResponse.Job.Webhooks)
{
    Console.WriteLine($"{webhook.Id} status: {webhook.Status}");
}
```

{% endtab %}
{% endtabs %}

## Envoi de plusieurs fichiers

L'API Mindee ne prend pas en charge l'envoi de plusieurs fichiers à la fois ; si vous traitez un grand nombre de fichiers, plusieurs stratégies s'offrent à vous.

Il existe deux cas d'utilisation typiques : la gestion des fichiers sur disque ou la gestion des téléversements des utilisateurs finaux.

### Fichiers sur disque

Lorsque vous devez traiter de grandes quantités de fichiers dans un répertoire ou plusieurs répertoires.

En général, il vous suffit de parcourir tous les fichiers des répertoires et d'appeler l'API pour chacun d'eux.

Ici, la préoccupation habituelle est le temps nécessaire pour traiter tous les fichiers.

Si vous utilisez l'interrogation, vous pouvez soit recourir au threading, soit à des processus asynchrones pour envoyer plusieurs fichiers en même temps. Votre langage de programmation et votre framework détermineront ce qui fonctionne le mieux.

Si vous utilisez des webhooks, votre débit sera nettement plus élevé qu'avec l'interrogation, sans avoir besoin d'utiliser le threading ou la programmation asynchrone. En effet, vous n'attendez pas que le serveur renvoie les résultats avant de passer au fichier suivant.

Dans les deux cas, faites attention aux [limites de téléversement de fichiers](/v2/fr/integrations/technical-limitations.md#rate-limits) sur le serveur Mindee. Le serveur répondra avec un code HTTP 429 en cas de téléversements de fichiers excessifs.

### Téléversements des utilisateurs finaux

Lorsque vous fournissez un service dans lequel un utilisateur final peut téléverser des documents directement sur votre plateforme.

Puisque tous les SDK Mindee offrent plusieurs façons de gérer les fichiers en mémoire, vous n'avez rien à écrire sur disque. Vous pouvez le faire si vous le souhaitez, bien sûr !

En général, vous utiliserez soit des octets bruts, soit un objet de flux, selon votre langage et votre framework. Envoyez-le directement au SDK Mindee et traitez-le comme d'habitude (interrogation ou webhook). Plus d'informations dans la section : [Charger et ajuster un fichier](/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md#load-a-source-file)

Avec ce type de configuration, l'interrogation est peut-être moins pénalisante pour les performances si vous disposez de plusieurs processus serveur en cours d'exécution et de peu d'utilisateurs.

Lorsque vous avez de nombreux utilisateurs téléversant de nombreux fichiers, autrement dit lorsque c'est une fonctionnalité centrale de votre produit ou de votre flux de travail, les webhooks vous offriront plus de flexibilité.\
Par exemple, vous pourriez faire en sorte que votre processus de téléversement envoie le fichier directement à Mindee, puis avoir un autre processus ou microservice pour gérer le traitement des résultats.

### Obtenir de l'aide pour l'intégration

L'assistant IA peut vous fournir du code personnalisé et des conseils.

Les utilisateurs Enterprise bénéficient d'une assistance d'intégration personnalisée ; n'hésitez pas à contacter notre équipe d'assistance.


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.mindee.com/v2/fr/integrations/client-libraries-sdk/send-a-file-or-url.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.