> 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

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

## Prérequis

Vous devrez configurer correctement votre client Mindee 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 devrez disposer 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 devrez disposer 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 modifier le fichier d'une quelconque manière avant l'envoi.

## Envoi avec interrogation

Envoyez un document en utilisant [l'interrogation](/v2/fr/integrations/polling-for-results.md), c'est la manière la plus simple pour commencer.

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

### Configuration de l'interrogation

N'oubliez pas d'utiliser la classe Produit/Modèle appropriée ; les exemples utilisent `ExtractionParameters`.

{% tabs %}
{% tab title="Python" %}
Lors de l'utilisation 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 définir les différents paramètres d'interrogation.\
Cependant, **nous ne recommandons pas** de définir cette option sauf si vous rencontrez des problèmes de délai d'attente.

```python
from mindee import PollingOptions

# À utiliser uniquement en cas de problèmes de délai d'attente.
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'utilisation de l'interrogation, vous n'avez vraiment besoin de définir que le `modelId` .

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

Vous pouvez également définir les différents paramètres d'interrogation.\
Cependant, **nous ne recommandons pas** de définir cette option sauf si vous rencontrez des problèmes de délai d'attente.

```typescript
// Facultatif, à définir uniquement en cas de problèmes de délai d'attente.
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'utilisation 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 définir les différents paramètres d'interrogation.\
Cependant, **nous ne recommandons pas** de définir cette option sauf si vous rencontrez des problèmes de délai d'attente.

```php
use Mindee\ClientOptions\PollingOptions;

// À définir uniquement en cas de problèmes de délai d'attente.
$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'utilisation 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 définir les différents paramètres d'interrogation.\
Cependant, **nous ne recommandons pas** de définir cette option sauf si vous rencontrez des problèmes de délai d'attente.

```ruby
# À définir uniquement en cas de problèmes de délai d'attente.
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'utilisation 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 définir les différents paramètres d'interrogation.\
Cependant, **nous ne recommandons pas** de définir cette option sauf si vous rencontrez des problèmes de délai d'attente.

```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étez le générateur d'interrogation
    .build();
```

{% endtab %}

{% tab title=".NET" %}
Lors de l'utilisation 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 définir les différents paramètres d'interrogation.\
Cependant, **nous ne recommandons pas** de définir cette option sauf si vous rencontrez des problèmes de délai d'attente.

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

```python
response = mindee_client.enqueue_and_get_result(
    InferenceResponse,
    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 Produit/Modèle appropriée ; les exemples utilisent `Extraction`.

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

// Gérez la Promise 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 Produit/Modèle appropriée ; les exemples utilisent `ExtractionResponse`.

```php
$response = $mindeeClient->enqueueAndGetResult(
    // Utilisez la classe produit appropriée
    ExtractionResponse::class,
    $inputSource,
    $modelParams,
    // facultatif, à définir uniquement 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 Produit/Modèle appropriée ; les exemples utilisent `Extraction`.

```ruby
response = mindee_client.enqueue_and_get_result(
  # Utilisez la classe 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 Produit/Modèle appropriée ; les exemples utilisent `ExtractionResponse`.

```java
var response = mindeeClient.enqueueAndGetResult(
    // Utilisez la classe produit appropriée
    ExtractionResponse.class,
    inputSource,
    modelParams
    // facultatif, à définir uniquement 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 produit/modèle appropriée ; les exemples utilisent `ExtractionResponse`.

```csharp
var response = await mindeeClient.EnqueueAndGetResultAsync<ExtractionResponse>(
    inputSource
    , modelParams
    // facultatif, à définir uniquement 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

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

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 enverra la requête en POST à votre serveur web, comme configuré par votre point de terminaison de webhook.

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

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

N'oubliez pas d'utiliser la classe Produit/Modèle 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 webhook

Vous pouvez spécifier autant d'ID de point de terminaison de webhook que nécessaire ; 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 devriez enregistrer l'ID de tâche pour vos archives/débogage
print(response.job.id)

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

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

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' `InferenceParameters` 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 devriez enregistrer l'ID de tâche pour vos archives/débogage
console.log(response.job.id);

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

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

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' `modelParams` objet.\
Puis, appelez `enqueueAndGetResult` et `await` 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 devriez enregistrer l'ID de tâche pour vos archives/débogage
echo strval($response->job->id);

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

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

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' `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 devriez enregistrer l'ID de tâche pour vos archives/débogage
puts response.job.id

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

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

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' `inference_params` hachage.\
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 devriez enregistrer l'ID de tâche pour vos archives/débogage
System.out.println(response.getJob().getId());

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

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

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' `InferenceParameters` 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 devriez enregistrer l'ID de tâche pour vos archives/débogage
System.Console.WriteLine(response.Job.Id);

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

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

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' `InferenceParameters` 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 de l' `Job` objet et des appels de méthode associés.

Si vous utilisez des webhooks, nous vous recommandons vivement d'enregistrer l'ID de la tâche 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 du traitement
* aux erreurs détaillées, le cas échéant
* au statut de chaque webhook envoyé
* aux heures de création et de fin
* etc.

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

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

# depuis la méthode `enqueue_and_get_result` (généralement pour interrogation)
# job_id = response.inference.job.id

job_response = mindee_client.get_job(job_id)

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

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

{% endtab %}

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

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

// depuis la méthode `enqueueAndGetResult` (généralement pour interrogation)
//const jobId = response.inference.job.id;

const jobResponse = await mindeeClient.getJob(jobId);

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

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

{% endtab %}

{% tab title="PHP" %}

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

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

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

// quelques métadonnées, vérifiez 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érifiez les webhooks
foreach ($jobResponse->job->webhooks as $webhook) {
    echo "{$webhook->id} status: {$webhook->status}";
}
```

{% endtab %}

{% tab title="Ruby" %}

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

# depuis la méthode `enqueue_and_get_result` (généralement pour interrogation)
# job_id = response.inference.job.id

job_response = mindee_client.get_job(job_id)

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

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

{% endtab %}

{% tab title="Java" %}

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

// depuis la méthode `enqueueAndGetInference` (généralement pour interrogation)
// String jobId = response.getInference().getJob().getId();

var jobResponse = mindeeClient.getJob(jobId);

// quelques métadonnées, vérifiez 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érifiez les webhooks
job.getWebhooks().forEach(webhook ->
    System.out.println(webhook.getId() + " status: " + webhook.getStatus())
);
```

{% endtab %}

{% tab title=".NET" %}

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

// depuis la méthode `EnqueueAndGetResultAsync` (généralement pour interrogation)
// var jobId = response.Inference.Job.Id;

var jobResponse = await mindeeClient.GetJobAsync(jobId);

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

// vérifiez 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 en une seule fois ; si vous traitez un grand nombre de fichiers, vous pouvez adopter plusieurs stratégies.

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

### Fichiers sur disque

Lorsque vous devez traiter un grand nombre de fichiers dans un répertoire ou plusieurs répertoires.

En général, vous vous contentez d'itérer sur tous les fichiers des répertoires et d'appeler l'API pour chacun d'eux.

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

Si vous utilisez l'interrogation, vous pouvez soit utiliser des threads, 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 multithreading 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 d'utilisateurs finaux

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

Comme tous les SDK Mindee offrent plusieurs façons de gérer les fichiers en mémoire, vous n'avez rien à écrire sur le 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 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 en termes de performances si vous disposez de plusieurs processus serveur en cours d'exécution et de peu d'utilisateurs.

Lorsque vous avez de nombreux utilisateurs qui téléversent de nombreux fichiers, en somme lorsque c'est une fonctionnalité centrale de votre produit ou de votre flux de travail, les webhooks vous offriront davantage de flexibilité.\
Par exemple, vous pourriez faire en sorte que votre processus de téléversement envoie le fichier directement à Mindee, puis utiliser un autre processus ou microservice pour traiter les 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 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/integrations/client-libraries-sdk/send-a-file-or-url.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.