> 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

## Prérequis

Vous devrez avoir votre client Mindee correctement configuré, comme décrit dans le [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 le [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 le [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 le [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.

## Envoyer 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

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

```python
model_params = InferenceParameters(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,
)

inference_params = InferenceParameters(
    # ID du model_id, requis.
    model_id="MY_MODEL_ID",
    
    # À définir uniquement en cas de problèmes de délai d'attente.
    # polling_options=polling_options,

    # ... toutes les autres options ...
)
```

{% 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 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'interrogation, vous n'avez vraiment besoin de définir que le `modelId` .

```php
$modelParams = new InferenceParameters(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\Input\PollingOptions;

$modelParams = new InferenceParameters(
    // ID du modèle, requis.
    modelId: "MY_MODEL_ID",
    
    // À 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,
    ),

    // ... toutes les autres options ...
);
```

{% 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 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'interrogation, vous n'avez vraiment besoin de définir que le `modelId` . N'oubliez pas d'utiliser la classe Product/Model appropriée, les exemples utilisent `ExtractionParameters`.

```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'interrogation, vous n'avez vraiment besoin de définir que le `modelId`. N'oubliez pas d'utiliser la classe Product/Model appropriée, les exemples utilisent `ExtractionParameters`.

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

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

Utilisez le `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" %}
L' `mindeeClient`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

Utilisez le `enqueueAndGetResult` méthode :

```typescript
const response = mindeeClient.enqueueAndGetResult(
  // Utilisez la classe de 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" %}
L' `$mindeeClient` , créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

Utilisez le `enqueueAndGetInference` méthode :

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

# 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" %}
L' `mindee_client`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

Utilisez le `enqueue_and_get_result` méthode.

```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" %}
L' `mindeeClient`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

Utilisez le `enqueueAndGetInference` 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 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" %}
L' `mindeeClient`, créé dans [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md).

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

## Envoyer avec webhook

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

### Configuration du webhook

La bibliothèque cliente enverra la requête en POST à votre serveur web, comme configuré par votre point de terminaison webhook.

Pour plus d'informations sur les webhooks, consultez le [Résultats des webhooks](/v2/fr/integrations/webhooks.md) page.

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

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

```python
model_params = InferenceParameters(
    # ID du model_id, requis.
    model_id="MY_MODEL_ID",
    
    # Ajoutez ici autant d'ID de webhook que nécessaire.
    webhook_ids=["ENDPOINT_1_UUID"],
    
    # ... toutes les autres options ...
)
```

{% endtab %}

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

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

  // Ajoutez ici autant d'IDs de webhook que vous le souhaitez.
  webhookIds: ["ENDPOINT_1_UUID"],

  // ... toutes les autres options ...
};
```

{% endtab %}

{% tab title="PHP" %}

```php
$modelParams = new InferenceParameters(
    // ID du modèle, requis.
    modelId: "MY_MODEL_ID",
    
    // Ajoutez ici autant d'IDs de webhook que vous le souhaitez.
    // Remarque : PHP 8.1 n'autorise qu'un seul ID à être transmis.
    webhooksIds: array("ENDPOINT_1_UUID"),

    // ... toutes les autres options ...
);
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
model_params = {
  # ID du model_id, requis.
  model_id: 'MY_MODEL_ID',

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

  # ... toutes les autres options ...
}
```

{% endtab %}

{% tab title="Java" %}
N'oubliez pas d'utiliser la classe product/model appropriée, les exemples utilisent `ExtractionParameters`.

```java
var modelParams = ExtractionParameters
    // ID du modèle, requis.
    .builder("MY_MODEL_ID")
    
    // Ajoutez ici autant d'IDs de webhook que vous le souhaitez.
    .webhookIds(new String[]{"ENDPOINT_1_UUID"})
    
    // ... toutes les autres options ...
    
    .build();
```

{% endtab %}

{% tab title=".NET" %}
N'oubliez pas d'utiliser la classe product/model appropriée, les exemples utilisent `ExtractionParameters`.

```csharp
var modelParams = new ExtractionParameters(
    // ID du modèle, requis.
    modelId: "MY_MODEL_ID"
    
    // Ajoutez ici autant d'IDs de webhook que vous le souhaitez.
    , webhookIds: new List<string>{ "ENDPOINT_1_UUID" }
    
    // ... toutes les autres options ...
);
```

{% endtab %}
{% endtabs %}

### Appel de méthode webhook

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

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

Utilisez le `enqueue_inference` méthode :

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

# Vous devriez enregistrer l'ID du job pour vos besoins d'archivage/débogage
print(response.job.id)

# Si vous définissez 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 à l' `InferenceParameters` instance.\
Puis, appelez `enqueue_and_get_result` .\
Vous obtiendrez la réponse via l'interrogation et des webhooks seront également envoyés.
{% endtab %}

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

Utilisez le `enqueue` méthode :

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

// Vous devriez enregistrer l'ID du job pour vos besoins d'archivage/débogage
console.log(response.job.id);

// Si vous définissez 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 à l' `modelParams` objet.\
Puis, appelez `enqueueAndGetResult` et `await` la Promise.\
Vous obtiendrez la réponse via l'interrogation et des webhooks seront également envoyés.
{% endtab %}

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

Utilisez le `enqueueInference` méthode :

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

// Vous devriez enregistrer l'ID du job pour vos besoins d'archivage/débogage
echo strval($response->job->id);

// Si vous définissez 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 à l' `InferenceParameters` instance.\
Puis, appelez `EnqueueAndGetResultAsync`.\
Vous obtiendrez la réponse via l'interrogation et des webhooks seront également envoyés.
{% endtab %}

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

Utilisez le `enqueue` méthode :

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

# Vous devriez enregistrer l'ID du job pour vos besoins d'archivage/débogage
puts response.job.id

# Si vous définissez 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 à l' `inference_params` hash.\
Puis, appelez `enqueue_and_get_result` .\
Vous obtiendrez la réponse via l'interrogation et des webhooks seront également envoyés.
{% endtab %}

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

Utilisez le `enqueueInference` méthode :

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

// Vous devriez enregistrer l'ID du job pour vos besoins d'archivage/débogage
System.out.println(response.getJob().getId());

// Si vous définissez 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 à l' `InferenceParameters` instance.\
Puis, appelez `enqueueAndGetInference` et gérez la Promise.\
Vous obtiendrez la réponse via l'interrogation et des webhooks seront également envoyés.
{% endtab %}

{% tab title=".NET" %}
L' `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.EnqueueInferenceAsync(
    inputSource, modelParams
);

// Vous devriez enregistrer l'ID du job pour vos besoins d'archivage/débogage
System.Console.WriteLine(response.Job.Id);

// Si vous définissez 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 à l' `InferenceParameters` instance.\
Puis, appelez `EnqueueAndGetResultAsync`.\
Vous obtiendrez la réponse via l'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' `Tâche` objet et des appels de méthodes 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
* le statut global du traitement
* les erreurs détaillées, le cas échéant
* le statut de chaque webhook envoyé
* les horodatages de création et d'achèvement
* etc.

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

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

# depuis 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, 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 les webhooks)
const jobId = response.job.id;

// depuis 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, 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 les webhooks)
$jobId = $response->job->id;

// depuis la méthode `enqueueAndGetInference` (généralement pour l'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 les webhooks)
job_id = response.job.id

# depuis 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, 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 les webhooks)
String jobId = response.getJob().getId();

// depuis 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, 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 les webhooks)
var jobId = response.Job.Id;

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

var jobResponse = await mindeeClientV2.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 %}


---

# 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:

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

The question should be specific, self-contained, and written in natural language.
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.