---
title: API Files
url: https://platform.claude.com/docs/fr/build-with-claude/files
description: Téléversez des fichiers une seule fois, référencez-les par file_id dans les requêtes Messages, et téléchargez les sorties créées par les skills ou l'outil d'exécution de code.
featureMetadata:
  status: ga
  zdr: not-eligible
  supportedPlatforms:
    Claude API: ga
    Claude Platform on AWS: ga
    Microsoft Foundry:
      availability: ga
      note: Sur [Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry), l'API Files nécessite un [déploiement hébergé sur Anthropic](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure).
---

L'API Files vous permet de téléverser et de gérer des fichiers à utiliser avec l'API Claude sans avoir à téléverser à nouveau le contenu à chaque requête. Cela est particulièrement utile lorsque vous utilisez l'[outil d'exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool) pour fournir des entrées (par exemple, des jeux de données et des documents), puis télécharger des sorties (par exemple, des graphiques). Vous pouvez [explorer directement la référence de l'API](https://platform.claude.com/docs/fr/api/files/upload), en complément de ce guide.

## Prise en charge des types de fichiers

Le référencement d'un `file_id` dans une requête Messages est pris en charge sur tous les modèles qui prennent en charge le type de fichier concerné. Les [images](https://platform.claude.com/docs/fr/build-with-claude/vision) sont prises en charge sur tous les modèles Claude actuels. Pour les [PDF](https://platform.claude.com/docs/fr/build-with-claude/pdf-support) et les [autres types de fichiers avec l'outil d'exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#compatibility), consultez les pages liées pour connaître la prise en charge par modèle.

## Fonctionnement de l'API Files

L'API Files propose une approche « créer une fois, utiliser plusieurs fois » pour travailler avec des fichiers :

* **Téléversez des fichiers** vers le stockage sécurisé d'Anthropic et recevez un `file_id` unique
* **Téléchargez des fichiers** créés par les skills ou l'outil d'exécution de code
* **Référencez des fichiers** dans les requêtes [Messages](https://platform.claude.com/docs/fr/api/messages/create) en utilisant le `file_id` au lieu de téléverser à nouveau le contenu
* **Gérez vos fichiers** avec les opérations de liste, de récupération et de suppression

<Warning id="workspace-scoped-access">
  **Les fichiers téléversés sont accessibles à l'ensemble de votre « workspace » (espace de travail), et ne sont pas limités à un utilisateur final, une conversation ou une session.** Toute clé API ayant accès à un espace de travail peut accéder à tous les fichiers téléversés dans cet espace de travail. Chaque compte de service, et chaque utilisateur dont le rôle dans l'organisation autorise l'accès à l'API, peut utiliser le Default Workspace en plus de tout espace de travail auquel vous l'ajoutez ; conservez donc les fichiers qui doivent rester séparés dans leur propre [espace de travail](https://platform.claude.com/docs/fr/manage-claude/workspaces#api-keys-and-resource-scoping) et n'y accédez qu'avec des clés limitées à cet espace de travail. N'acceptez jamais de valeurs `file_id` provenant d'utilisateurs finaux ou d'autres sources non fiables : un identifiant de fichier fourni par un utilisateur permettrait à un utilisateur de votre application de lire le contenu téléversé par un autre utilisateur. Traitez les identifiants de fichiers comme des références côté serveur, et conservez la correspondance entre vos utilisateurs et leurs fichiers dans votre application.

  Si vous développez une application multi-locataire sur l'API Files, créez un [espace de travail](https://platform.claude.com/docs/fr/manage-claude/workspaces) distinct pour chaque locataire. L'espace de travail constitue la frontière d'isolation des fichiers ; un espace de travail par locataire offre donc aux données de chaque locataire une isolation stricte vis-à-vis de tous les autres locataires. Chaque organisation peut disposer de jusqu'à 100 espaces de travail ; contactez votre équipe de compte si vous en avez besoin de davantage.
</Warning>

## Comment utiliser l'API Files

### Téléverser un fichier

Téléversez un fichier à référencer dans de futurs appels API :

<CodeGroup>
  ```bash cURL
  curl -X POST https://api.anthropic.com/v1/files \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -F "file=@/path/to/document.pdf"
  ```

  ```bash CLI
  ant files upload --file /path/to/document.pdf
  ```

  ```python Python
  uploaded = client.files.upload(
      file=("document.pdf", open("/path/to/document.pdf", "rb"), "application/pdf"),
  )
  file_id = uploaded.id
  print(file_id)
  ```

  ```typescript TypeScript
  const uploaded = await client.files.upload({
    file: await toFile(fs.createReadStream("/path/to/document.pdf"), undefined, {
      type: "application/pdf"
    })
  });
  console.log(uploaded.id);
  ```

  ```csharp C#
  var uploaded = await client.Files.Upload(
      new FileUploadParams
      {
          File = new BinaryContent
          {
              Stream = File.OpenRead("/path/to/document.pdf"),
              FileName = "document.pdf",
              ContentType = new("application/pdf")
          }
      });

  var fileId = uploaded.ID;
  Console.WriteLine(fileId);
  ```

  ```go Go
  f, err := os.Open("/path/to/document.pdf")
  if err != nil {
  	log.Fatal(err)
  }
  defer f.Close()

  response, err := client.Files.Upload(context.Background(),
  	anthropic.FileUploadParams{
  		File: anthropic.File(f, "document.pdf", "application/pdf"),
  	})
  if err != nil {
  	log.Fatal(err)
  }

  fileID := response.ID
  fmt.Println(fileID)
  ```

  ```java Java
  FileMetadata file = client.files().upload(
      FileUploadParams.builder()
          .file(MultipartField.<InputStream>builder()
              .value(Files.newInputStream(Path.of("/path/to/document.pdf")))
              .filename("document.pdf")
              .contentType("application/pdf")
              .build())
          .build()
  );

  String fileId = file.id();
  System.out.println(fileId);
  ```

  ```php PHP
  $file = $client->files->upload(
      file: FileParam::fromResource(fopen('/path/to/document.pdf', 'rb'), contentType: 'application/pdf'),
  );

  $fileId = $file->id;
  echo $fileId;
  ```

  ```ruby Ruby
  file = client.files.upload(
    file: Anthropic::FilePart.new(
      Pathname("/path/to/document.pdf"),
      content_type: "application/pdf"
    )
  )

  file_id = file.id
  puts file_id
  ```
</CodeGroup>

La réponse au téléversement d'un fichier comprend :

```json Response
{
  "id": "file_011CNha8iCJcU1wXNR6q4V8w",
  "type": "file",
  "filename": "document.pdf",
  "mime_type": "application/pdf",
  "size_bytes": 1024000,
  "created_at": "2025-01-01T00:00:00Z",
  "downloadable": false,
  "expires_at": null
}
```

`downloadable` vaut `false` pour les fichiers que vous téléversez. Seuls les fichiers créés par les [skills](https://platform.claude.com/docs/fr/build-with-claude/skills-guide) ou l'[outil d'exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool) peuvent être téléchargés. Consultez [Télécharger un fichier](https://platform.claude.com/docs/fr/build-with-claude/files#downloading-a-file).

### Utiliser un fichier dans les messages

Une fois téléversé, référencez le fichier en transmettant l'`id` de la réponse de téléversement en tant que `file_id` :

<CodeGroup>
  ```bash cURL
  curl -X POST https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "messages": [
        {
          "role": "user",
          "content": [
            {
              "type": "text",
              "text": "Please summarize this document for me."
            },
            {
              "type": "document",
              "source": {
                "type": "file",
                "file_id": "'"$FILE_ID"'"
              }
            }
          ]
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<YAML
  model: claude-opus-5-5
  max_tokens: 1024
  messages:
    - role: user
      content:
        - type: text
          text: Please summarize this document for me.
        - type: document
          source:
            type: file
            file_id: $FILE_ID
  YAML
  ```

  ```python Python
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {"type": "text", "text": "Please summarize this document for me."},
                  {
                      "type": "document",
                      "source": {
                          "type": "file",
                          "file_id": file_id,
                      },
                  },
              ],
          }
      ],
  )
  print(response)
  ```

  ```typescript TypeScript
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: "Please summarize this document for me."
          },
          {
            type: "document",
            source: {
              type: "file",
              file_id: uploaded.id
            }
          }
        ]
      }
    ]
  });

  console.log(response);
  ```

  ```csharp C#
  var response = await client.Messages.Create(
      new MessageCreateParams
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 1024,
          Messages =
          [
              new MessageParam
              {
                  Role = Role.User,
                  Content = new List<ContentBlockParam>
                  {
                      new TextBlockParam { Text = "Please summarize this document for me." },
                      new DocumentBlockParam
                      {
                          Source = new FileDocumentSource { FileID = fileId }
                      }
                  }
              }
          ]
      });

  Console.WriteLine(response);
  ```

  ```go Go
  msg, err := client.Messages.New(context.Background(),
  	anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 1024,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(
  				anthropic.NewTextBlock("Please summarize this document for me."),
  				anthropic.NewDocumentBlock(anthropic.FileDocumentSourceParam{
  					FileID: fileID,
  				}),
  			),
  		},
  	})
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(msg)
  ```

  ```java Java
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(1024)
      .addUserMessageOfBlockParams(List.of(
          ContentBlockParam.ofText(TextBlockParam.builder()
              .text("Please summarize this document for me.")
              .build()),
          ContentBlockParam.ofDocument(DocumentBlockParam.builder()
              .fileSource(fileId)
              .build())
      ))
      .build();

  Message message = client.messages().create(params);
  System.out.println(message);
  ```

  ```php PHP
  $response = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  ['type' => 'text', 'text' => 'Please summarize this document for me.'],
                  [
                      'type' => 'document',
                      'source' => [
                          'type' => 'file',
                          'fileID' => $fileId,
                      ],
                  ],
              ],
          ],
      ],
      model: 'claude-opus-5-5',
  );

  echo $response;
  ```

  ```ruby Ruby
  response = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          { type: "text", text: "Please summarize this document for me." },
          {
            type: "document",
            source: {
              type: "file",
              file_id: file_id
            }
          }
        ]
      }
    ]
  )

  puts response
  ```
</CodeGroup>

### Types de fichiers et blocs de contenu

L'API Files prend en charge différents types de fichiers qui correspondent à différents types de blocs de contenu :

| Type de fichier                                                                                                                                | Type MIME                                            | Type de bloc de contenu | Cas d'usage                                    |
| ---------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- | ----------------------- | ---------------------------------------------- |
| PDF                                                                                                                                            | `application/pdf`                                    | `document`              | Analyse de texte, traitement de documents      |
| Texte brut                                                                                                                                     | `text/plain`                                         | `document`              | Analyse de texte, traitement                   |
| Images                                                                                                                                         | `image/jpeg`, `image/png`, `image/gif`, `image/webp` | `image`                 | Analyse d'images, tâches visuelles             |
| [Jeux de données, autres](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#upload-and-analyze-your-own-files) | Variable                                             | `container_upload`      | Analyser des données, créer des visualisations |

#### Blocs document

Pour les PDF et les fichiers texte, utilisez le bloc de contenu `document` :

```json
{
  "type": "document",
  "source": {
    "type": "file",
    "file_id": "file_011CNha8iCJcU1wXNR6q4V8w"
  },
  "title": "Document Title", // Optional
  "context": "Context about the document", // Optional
  "citations": { "enabled": true } // Optional, enables citations
}
```

#### Blocs image

Pour les images, utilisez le bloc de contenu `image` :

```json
{
  "type": "image",
  "source": {
    "type": "file",
    "file_id": "file_011CPMxVD3fHLUhvTqtsQA5w"
  }
}
```

#### Blocs container upload

Pour envoyer un fichier à l'[outil d'exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#upload-and-analyze-your-own-files), utilisez le bloc de contenu `container_upload` :

```json
{
  "type": "container_upload",
  "file_id": "file_011CNha8iCJcU1wXNR6q4V8w"
}
```

### Travailler avec d'autres formats de fichiers

Pour les types de fichiers que le bloc `document` ne prend pas en charge (par exemple, .docx et .xlsx), convertissez les fichiers en texte brut et incluez le contenu directement dans votre message. Les fichiers qui sont déjà en texte brut, tels que les fichiers .csv et .md, peuvent soit être lus de cette manière, soit être téléversés via l'API Files avec un type de contenu `text/plain` explicite. Pour analyser des jeux de données plutôt que de les lire comme du texte, téléversez-les pour l'[outil d'exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#upload-and-analyze-your-own-files) à l'aide d'un bloc `container_upload`.

Les exemples suivants lisent un fichier texte et envoient son contenu sous forme de texte brut :

<CodeGroup>
  ```bash cURL
  # Lire le fichier texte.
  # Remarque : pour les fichiers contenant des caractères spéciaux, envisagez un encodage base64.
  TEXT_CONTENT=$(cat document.txt)

  curl https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -d @- <<EOF
  {
    "model": "claude-opus-5-5",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "Here's the document content:\n\n${TEXT_CONTENT}\n\nPlease summarize this document."
          }
        ]
      }
    ]
  }
  EOF
  ```

  ```bash CLI
  # La référence "@./path" insère le contenu du fichier directement dans le champ.
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 1024 \
    --transform 'content.#(type=="text").text' \
    --raw-output <<'YAML'
  messages:
    - role: user
      content:
        - type: text
          text: "Here's the document content:"
        - type: text
          text: "@./document.txt"
        - type: text
          text: "Please summarize this document."
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  # Lire le fichier texte
  with open("document.txt") as f:
      text_content = f.read()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": [
                  {
                      "type": "text",
                      "text": f"Here's the document content:\n\n{text_content}\n\nPlease summarize this document.",
                  }
              ],
          }
      ],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  import fs from "node:fs/promises";
  // ...
  const client = new Anthropic();

  // Lire le fichier texte
  const textContent = await fs.readFile("document.txt", "utf-8");

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: `Here's the document content:\n\n${textContent}\n\nPlease summarize this document.`
          }
        ]
      }
    ]
  });

  const textBlock = response.content.find(
    (block): block is Anthropic.TextBlock => block.type === "text"
  );
  console.log(textBlock?.text);
  ```

  ```csharp C#
  AnthropicClient client = new();

  // Lire le fichier texte
  string textContent = await File.ReadAllTextAsync("document.txt");

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages = [new()
      {
          Role = Role.User,
          Content = $"Here's the document content:\n\n{textContent}\n\nPlease summarize this document."
      }]
  };

  var message = await client.Messages.Create(parameters);
  foreach (var block in message.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  // Lire le fichier texte
  textContent, err := os.ReadFile("document.txt")
  if err != nil {
  	log.Fatal(err)
  }

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock(
  			fmt.Sprintf("Here's the document content:\n\n%s\n\nPlease summarize this document.", string(textContent)),
  		)),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Lire le fichier texte
  String textContent = Files.readString(Path.of("document.txt"));

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(1024L)
      .addUserMessage("Here's the document content:\n\n" + textContent + "\n\nPlease summarize this document.")
      .build();

  Message response = client.messages().create(params);
  response.content().stream()
      .flatMap(block -> block.text().stream())
      .forEach(textBlock -> System.out.println(textBlock.text()));
  ```

  ```php PHP
  $client = new Client();

  // Lire le fichier texte
  $textContent = file_get_contents("document.txt");

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'text',
                      'text' => "Here's the document content:\n\n{$textContent}\n\nPlease summarize this document."
                  ]
              ]
          ]
      ],
      model: 'claude-opus-5-5',
  );

  foreach ($message->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  # Lire le fichier texte
  text_content = File.read("document.txt")

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: [
          {
            type: "text",
            text: "Here's the document content:\n\n#{text_content}\n\nPlease summarize this document."
          }
        ]
      }
    ]
  )

  message.content.each do |block|
    puts block.text if block.type == :text
  end
  ```
</CodeGroup>

<Note>
  Pour les fichiers .docx contenant des images, convertissez-les d'abord au format PDF, puis utilisez la [prise en charge des PDF](https://platform.claude.com/docs/fr/build-with-claude/pdf-support) pour tirer parti de l'analyse d'images intégrée. Cela permet d'utiliser les citations du document PDF.
</Note>

### Gérer les fichiers

#### Lister les fichiers

Récupérez la liste de vos fichiers téléversés. Le point de terminaison est paginé : chaque requête renvoie jusqu'à `limit` fichiers (20 par défaut, et 1 000 au maximum), et le curseur `next_page` de la réponse permet de récupérer la page suivante lorsqu'il est renvoyé en tant que paramètre `page`. Les fichiers sont triés du plus récent au plus ancien. Consultez la [référence de l'API List Files](https://platform.claude.com/docs/fr/api/files/list). Le SDK renvoie la première page et fournit des utilitaires de [pagination automatique](https://platform.claude.com/docs/fr/api/overview#pagination). L'exemple CLI limite le total avec `--max-items` :

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/files \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  ant files list --max-items 10
  ```

  ```python Python
  client = anthropic.Anthropic()
  files = client.files.list()
  print(files)
  ```

  ```typescript TypeScript
  const client = new Anthropic();
  const files = await client.files.list();
  console.log(files);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var files = await client.Files.List();
  Console.WriteLine(files);
  ```

  ```go Go
  client := anthropic.NewClient()

  files, err := client.Files.List(context.TODO(), anthropic.FileListParams{})
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(files)
  ```

  ```java Java
  import com.anthropic.models.files.FileListPage;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      FileListPage files = client.files().list();
      System.out.println(files);
  }
  ```

  ```php PHP
  $client = new Client();

  $files = $client->files->list();
  echo $files;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  files = client.files.list
  puts files
  ```
</CodeGroup>

Pour vérifier un ensemble connu de fichiers en une seule requête plutôt que de paginer, transmettez jusqu'à 100 identifiants de fichiers en tant que paramètres de requête `ids[]`. Une requête `ids[]` renvoie toujours une seule page (`next_page` vaut `null`), et tout identifiant qui ne correspond pas à un fichier de votre espace de travail est silencieusement omis de `data` ; comparez les identifiants renvoyés aux identifiants demandés pour détecter les absences. `ids[]` ne peut pas être combiné avec `page` ou `limit`.

#### Obtenir les métadonnées d'un fichier

Récupérez des informations sur un fichier spécifique :

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/files/$FILE_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  ant files retrieve-metadata \
    --file-id "$FILE_ID"
  ```

  ```python Python
  file = client.files.retrieve_metadata(file_id)
  print(file)
  ```

  ```typescript TypeScript
  const file = await client.files.retrieveMetadata(uploaded.id);
  console.log(file);
  ```

  ```csharp C#
  var file = await client.Files.RetrieveMetadata(fileId);
  Console.WriteLine(file);
  ```

  ```go Go
  metadata, err := client.Files.GetMetadata(context.TODO(), fileID, anthropic.FileGetMetadataParams{})
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println(metadata)
  ```

  ```java Java
  FileMetadata metadata = client.files().retrieveMetadata(fileId);

  System.out.println(metadata);
  ```

  ```php PHP
  $file = $client->files->retrieveMetadata($fileId);
  echo $file;
  ```

  ```ruby Ruby
  file = client.files.retrieve_metadata(file_id)
  puts file
  ```
</CodeGroup>

#### Supprimer un fichier

Supprimez un fichier de votre espace de travail :

<CodeGroup>
  ```bash cURL
  curl -X DELETE "https://api.anthropic.com/v1/files/$FILE_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  ant files delete \
    --file-id "$FILE_ID"
  ```

  ```python Python
  client.files.delete(file_id)
  ```

  ```typescript TypeScript
  await client.files.delete(uploaded.id);
  ```

  ```csharp C#
  await client.Files.Delete(fileId);
  ```

  ```go Go
  _, err = client.Files.Delete(context.TODO(), fileID, anthropic.FileDeleteParams{})
  if err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java
  client.files().delete(fileId);
  ```

  ```php PHP
  $client->files->delete($fileId);
  ```

  ```ruby Ruby
  client.files.delete(file_id)
  ```
</CodeGroup>

### Télécharger un fichier

Téléchargez les fichiers créés par les [skills](https://platform.claude.com/docs/fr/build-with-claude/skills-guide) ou l'[outil d'exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool). Les fichiers que vous téléversez ne peuvent pas être téléchargés. Le `file_id` d'un fichier généré apparaît dans le [bloc de contenu `bash_code_execution_tool_result`](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#retrieve-generated-files) de la réponse Messages qui l'a créé :

<CodeGroup>
  ```bash cURL
  curl -X GET "https://api.anthropic.com/v1/files/$FILE_ID/content" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    --output downloaded_file.txt
  ```

  ```bash CLI
  ant files download \
    --file-id "$FILE_ID" \
    --output downloaded_file.txt
  ```

  ```python Python
  file_content = client.files.download(file_id)

  file_content.write_to_file("downloaded_file.txt")
  ```

  ```typescript TypeScript
  const content = await client.files.download(uploaded.id);

  const bytes = Buffer.from(await content.arrayBuffer());
  await fsp.writeFile("downloaded_file.txt", bytes);
  ```

  ```csharp C#
  using var fileContent = await client.Files.Download(fileId);
  await using var source = await fileContent.ReadAsStream();
  await using var destination = File.Create("downloaded_file.txt");
  await source.CopyToAsync(destination);
  ```

  ```go Go
  func downloadFile(client anthropic.Client, fileID string) error {
  	resp, err := client.Files.Download(context.TODO(), fileID, anthropic.FileDownloadParams{})
  	if err != nil {
  		return err
  	}
  	defer resp.Body.Close()

  	out, err := os.Create("downloaded_file.txt")
  	if err != nil {
  		return err
  	}
  	defer out.Close()

  	_, err = io.Copy(out, resp.Body)
  	return err
  }
  ```

  ```java Java
  try (HttpResponse response = client.files().download(fileId)) {
      try (InputStream body = response.body()) {
          Files.copy(body, Path.of("downloaded_file.txt"),
              StandardCopyOption.REPLACE_EXISTING);
      }
  }
  ```

  ```php PHP
  $fileContent = $client->files->download($fileId);

  file_put_contents('downloaded_file.txt', $fileContent);
  ```

  ```ruby Ruby
  file_content = client.files.download(file_id)

  File.binwrite("downloaded_file.txt", file_content.read)
  ```
</CodeGroup>

<Note>
  Un fichier n'est téléchargeable que lorsque ses métadonnées indiquent `"downloadable": true`, ce qui est le cas des fichiers créés par les skills ou l'outil d'exécution de code. Le téléchargement d'un fichier que vous avez téléversé renvoie une erreur 400.
</Note>

Sur l'API Claude, les fichiers image, vidéo et audio pris en charge que Claude produit avec l'outil d'exécution de code, y compris les fichiers créés par les skills, comportent des Content Credentials C2PA signés lorsque vous les téléchargez. Consultez [Content Credentials sur les fichiers générés](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#content-credentials-on-generated-files) pour savoir ce que contient l'identifiant et comment le vérifier.

## Stockage des fichiers et limites

### Limites de stockage

* **Taille maximale de fichier :** 500 Mo par fichier
* **Stockage total :** 1 To par organisation

### Cycle de vie des fichiers

* Les fichiers sont limités à l'espace de travail dans lequel ils ont été téléversés. Toute requête dans le même espace de travail peut les référencer ; n'acceptez jamais d'identifiants de fichiers provenant de sources non fiables (voir l'[avertissement sur l'accès à l'espace de travail](https://platform.claude.com/docs/fr/build-with-claude/files#workspace-scoped-access))
* Les fichiers ne peuvent pas être modifiés ni renommés après le téléversement. Pour modifier le contenu d'un fichier, téléversez un nouveau fichier et supprimez l'ancien
* Les fichiers persistent jusqu'à ce que vous les supprimiez avec le point de terminaison `DELETE /v1/files/{file_id}` ou qu'ils atteignent leur `expires_at`
* Les fichiers supprimés ne peuvent pas être récupérés
* Les fichiers deviennent inaccessibles via l'API peu après leur suppression, mais ils peuvent persister dans les appels actifs à l'API Messages et les utilisations d'outils associées
* Les fichiers que les utilisateurs suppriment seront supprimés conformément à la [politique de conservation des données](https://privacy.claude.com/en/articles/7996866-how-long-do-you-store-my-organization-s-data) d'Anthropic. Pour l'éligibilité ZDR de l'ensemble des fonctionnalités, consultez [API et conservation des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention)

### Expiration des fichiers

Pour qu'un fichier expire automatiquement, incluez un champ de formulaire `expires_in_seconds` lors de son téléversement. La valeur est un nombre entier de secondes compris entre 3 600 (1 heure) et 7 776 000 (90 jours). L'horodatage `expires_at` résultant (RFC 3339) apparaît dans chaque réponse de fichier et vaut `null` pour les fichiers téléversés sans expiration. L'expiration est définie une seule fois au téléversement et ne peut pas être modifiée.

Lorsqu'un fichier atteint son `expires_at` :

* Le téléchargement de son contenu (`GET /v1/files/{file_id}/content`) renvoie une erreur 404
* Une requête Messages qui référence le fichier échoue avant l'inférence
* Ses métadonnées (`GET /v1/files/{file_id}`) restent lisibles pendant 30 jours au maximum, avec `expires_at` dans le passé
* Il continue d'apparaître dans les réponses de liste pendant cette période ; comparez `expires_at` à l'heure actuelle pour filtrer les fichiers expirés

La suppression d'un fichier expiré avec `DELETE /v1/files/{file_id}` supprime immédiatement ses métadonnées au lieu d'attendre l'écoulement de la période de 30 jours.

<Note>
  L'expiration est une fonctionnalité de cycle de vie, et non un contrôle de suppression garantie. Après `expires_at`, le contenu du fichier n'est plus récupérable via l'API et est libéré de votre quota de stockage ; le contenu sous-jacent peut être conservé pendant une période limitée par la suite à des fins d'examen de sécurité avant sa suppression définitive, et les métadonnées du fichier restent visibles pendant 30 jours au maximum après l'expiration. Pour supprimer un fichier avant son expiration programmée, utilisez `DELETE /v1/files/{file_id}`.
</Note>

### Journalisation d'audit

Si votre organisation a activé la [Compliance API](https://platform.claude.com/docs/fr/manage-claude/compliance-api), son [Activity Feed](https://platform.claude.com/docs/fr/manage-claude/compliance-activity-feed) (flux d'activité) enregistre les opérations de l'API Files effectuées avec une clé API Claude ou depuis la Claude Console : chaque téléversement (`POST /v1/files`), téléchargement de contenu (`GET /v1/files/{file_id}/content`) et suppression (`DELETE /v1/files/{file_id}`) apparaît sous la forme d'une activité `platform_file_uploaded`, `platform_file_content_downloaded` ou `platform_file_deleted`. Le listage des fichiers et la récupération des métadonnées de fichiers ne sont pas enregistrés. Les opérations qui ont lieu pendant que la Compliance API est désactivée ne sont pas enregistrées et ne peuvent pas être récupérées ultérieurement ; [configurez donc la Compliance API](https://platform.claude.com/docs/fr/manage-claude/compliance-api-access) avant de vous appuyer sur cette piste d'audit. Sur [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#monitoring-and-logging), auditez plutôt les opérations sur les fichiers à l'aide des événements de données AWS CloudTrail.

## Migrer depuis `files-api-2025-04-14`

L'API Files n'est plus en bêta et ne nécessite aucun en-tête bêta. La migration depuis `files-api-2025-04-14` est facultative : les requêtes qui l'envoient encore continuent de fonctionner et de renvoyer les formes de réponse bêta, de sorte qu'une intégration existante continue de fonctionner jusqu'à ce que vous la modifiiez. La suppression de l'en-tête fait basculer ces requêtes vers les formes documentées sur cette page :

|                                                   | Avec `files-api-2025-04-14`             | Sans l'en-tête                                                                       |
| ------------------------------------------------- | --------------------------------------- | ------------------------------------------------------------------------------------ |
| Réponse de liste                                  | `{ data, has_more, first_id, last_id }` | `{ data, next_page }` ; renvoyez `next_page` en tant que paramètre de requête `page` |
| Curseurs de liste                                 | `before_id`, `after_id`                 | `page`, ou jusqu'à 100 `ids[]` (`before_id` et `after_id` renvoient une erreur 400)  |
| `expires_at` sur les objets fichier               | Non renvoyé                             | Toujours présent ; `null` lorsque le fichier n'a pas d'expiration                    |
| `Content-Type` sur la partie du fichier téléversé | Obligatoire                             | Facultatif ; le type est détecté lorsqu'il est omis                                  |

Pour migrer :

1. **Supprimez l'en-tête bêta.** Retirez `anthropic-beta: files-api-2025-04-14` de vos requêtes. Dans les SDK, appelez `client.files` au lieu de `client.beta.files` ; conserver `client.beta.files` ne fonctionne que sur les [versions de SDK qui n'envoient plus l'en-tête](https://platform.claude.com/docs/fr/build-with-claude/files#sdk-beta-namespace). Les versions antérieures l'envoient depuis `client.beta.files` même sans argument `betas`.
2. **Mettez à jour la pagination.** Remplacez les boucles `after_id`/`before_id` par le curseur `page`/`next_page`, ou utilisez les utilitaires de pagination automatique des SDK présentés dans [Gérer les fichiers](https://platform.claude.com/docs/fr/build-with-claude/files#managing-files).
3. **Lisez `expires_at`.** Le champ n'apparaît que sans l'en-tête ; `null` signifie que le fichier n'a pas d'expiration (voir [Expiration des fichiers](https://platform.claude.com/docs/fr/build-with-claude/files#file-expiration)).

### Espace de noms bêta des SDK

À partir du SDK Python 1.2.0, du SDK TypeScript 0.122.0, du SDK Go 1.68.0, du SDK Java 2.59.0, du SDK Ruby 1.67.0 et du SDK C# 12.44.0, `client.beta.files` n'envoie plus `files-api-2025-04-14` et renvoie les mêmes formes que `client.files`, avec des noms de types préfixés par `Beta`. Il accepte un argument `betas` pour les fonctionnalités Files encore en bêta, telles que le filtrage par `scope_id` sous un en-tête bêta [Managed Agents](https://platform.claude.com/docs/fr/managed-agents/files). Les versions antérieures des SDK sont typées selon les formes bêta ; si vous dépendez de ces types, restez sur une version antérieure jusqu'à votre migration.

Les requêtes qui portent `anthropic-beta: managed-agents-2026-04-01` sans `files-api-2025-04-14` reçoivent les formes de cette page avec une facilité de compatibilité sur `GET /v1/files` : `before_id` et `after_id` sont toujours acceptés (non combinables avec `page` ou `ids[]`), et la réponse de liste inclut `has_more`, `first_id` et `last_id` en plus de `next_page`. Les versions bêta ultérieures de Managed Agents reçoivent la forme simple.

## Gestion des erreurs

Les erreurs courantes lors de l'utilisation de l'API Files comprennent :

* **Fichier introuvable (404) :** Le `file_id` spécifié n'existe pas ou vous n'y avez pas accès
* **Type de fichier invalide (400) :** Le type de fichier ne correspond pas au type de bloc de contenu (par exemple, utilisation d'un fichier image dans un bloc document)
* **Non téléchargeable (400) :** Les fichiers que vous téléversez ont `"downloadable": false` et ne peuvent pas être téléchargés. Seuls les fichiers créés par les skills ou l'outil d'exécution de code peuvent être téléchargés
* **Dépassement de la taille de la fenêtre de contexte (400) :** Le fichier est plus grand que la taille de la « context window » (fenêtre de contexte) (par exemple, utilisation d'un fichier texte brut de 500 Mo dans une requête `/v1/messages`)
* **Nom de fichier invalide (400) :** Le nom du fichier ne respecte pas les exigences de longueur (1 à 255 caractères) ou contient des caractères interdits (`<`, `>`, `:`, `"`, `|`, `?`, `*`, `\`, `/`, ou les caractères Unicode 0 à 31)
* **Fichier trop volumineux (413) :** Le fichier dépasse la limite de 500 Mo
* **Limite de stockage dépassée (400) :** Votre organisation a atteint la limite de stockage de 1 To

```json Output
{
  "type": "error",
  "error": {
    "type": "not_found_error",
    "message": "File `file_011CNha8iCJcU1wXNR6q4V8w` not found."
  },
  "request_id": "req_011CQFYcrRp7mCHLDsAYT8Qt"
}
```

## Utilisation et facturation

Les opérations de l'API Files sont gratuites :

* Téléversement de fichiers
* Téléchargement de fichiers
* Listage des fichiers
* Obtention des métadonnées de fichiers
* Suppression de fichiers

Le contenu des fichiers utilisé dans les requêtes Messages est facturé en tant que tokens d'entrée.

### Limites de débit

Les appels API liés aux fichiers sont limités à environ 500 requêtes par minute. Pour demander une « rate limit » (limite de débit) plus élevée, [contactez l'équipe commerciale](mailto:sales@anthropic.com).

## Prochaines étapes

<CardGroup cols={3}>
  <Card title="Prise en charge des PDF" icon="file" href="https://platform.claude.com/docs/fr/build-with-claude/pdf-support">
    Traitez des PDF avec Claude. Extrayez du texte, analysez des graphiques et comprenez le contenu visuel de vos documents.
  </Card>

  <Card title="Outil d'exécution de code" icon="terminal" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool">
    Exécutez du code Python et bash dans un conteneur isolé pour analyser des données, générer des fichiers et itérer sur des solutions.
  </Card>

  <Card title="Vision" icon="image" href="https://platform.claude.com/docs/fr/build-with-claude/vision">
    Traitez et analysez des entrées visuelles et générez du texte et du code à partir d'images.
  </Card>
</CardGroup>