Claude Platform Docs
MessagesTravailler avec des fichiers

Prise en charge des PDF

Traitez des PDF avec Claude : extrayez du texte, analysez des graphiques et comprenez le contenu visuel de vos documents.

Vous pouvez interroger Claude sur n’importe quel texte, image, graphique ou tableau contenu dans les PDF que vous fournissez. Quelques exemples de cas d’utilisation :

  • Analyser des rapports financiers et comprendre des graphiques/tableaux
  • Extraire des informations clés de documents juridiques
  • Aider à la traduction de documents
  • Convertir les informations d’un document en formats structurés

Avant de commencer

Vérifier les exigences relatives aux PDF

Claude fonctionne avec n’importe quel PDF standard. Assurez-vous que la taille de votre requête respecte ces exigences :

ExigenceLimite
Taille maximale de la requête128 Mo sur l’API Claude propriétaire (varie selon la plateforme ; consultez les limites de taille des requêtes)
Nombre maximal de pages par requête600 (100 lorsque la fenêtre de contexte de la requête est inférieure à 1 million de tokens)
FormatPDF standard (sans mot de passe ni chiffrement)

Les deux limites s’appliquent à l’ensemble de la charge utile de la requête, y compris tout autre contenu envoyé avec les PDF. Pour les PDF volumineux, envisagez de les téléverser avec l’API Files et de les référencer par file_id afin de limiter la taille des charges utiles des requêtes.

Comme la prise en charge des PDF repose sur les capacités de vision de Claude, elle est soumise aux mêmes limitations et considérations que les autres tâches de vision.

Plateformes et modèles pris en charge

Tous les modèles actifs prennent en charge le traitement des PDF.

Traiter des PDF avec Claude

Envoyer votre première requête PDF

Commencez par un exemple simple utilisant l’API Messages. Vous pouvez fournir des PDF à Claude de trois manières :

  1. Sous forme de référence URL vers un PDF hébergé en ligne
  2. Sous forme de PDF encodé en base64 dans des blocs de contenu document
  3. Par un file_id provenant de l’API Files

Option 1 : document PDF basé sur une URL

L’approche la plus simple consiste à référencer un PDF directement depuis une URL :

client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "url",
                        "url": "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf",
                    },
                },
                {"type": "text", "text": "What are the key findings in this document?"},
            ],
        }
    ],
)

print(message.content)

La réponse renvoie l’analyse de Claude sous forme de blocs de texte dans content, avec la consommation de tokens dans usage :

Output
{
  "id": "msg_01Hfp8YuFjQ55VgWbpdHDehB",
  "type": "message",
  "role": "assistant",
  "model": "claude-opus-5-5",
  "content": [
    {
      "type": "text",
      "text": "This document is an addendum to the Claude 3 model card, reporting updated evaluation results. The key findings include..."
    }
  ],
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 45000,
    "output_tokens": 300
  }
}

Option 2 : document PDF encodé en base64

Si vous devez envoyer des PDF depuis votre système local ou lorsqu’aucune URL n’est disponible :

import base64
import httpx2

# Tout d'abord, chargez et encodez le PDF.
pdf_url = "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf"
pdf_data = base64.standard_b64encode(
    httpx2.get(pdf_url, follow_redirects=True).content
).decode("utf-8")

# Alternative : chargez depuis un fichier local.
# with open("document.pdf", "rb") as f:
#     pdf_data = base64.standard_b64encode(f.read()).decode("utf-8")

# Envoyez à Claude en utilisant l'encodage base64.
client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "base64",
                        "media_type": "application/pdf",
                        "data": pdf_data,
                    },
                },
                {"type": "text", "text": "What are the key findings in this document?"},
            ],
        }
    ],
)

print(message.content)

Option 3 : API Files

Pour les PDF que vous utiliserez de manière répétée, ou lorsque vous souhaitez éviter la surcharge liée à l’encodage, utilisez l’API Files :

client = anthropic.Anthropic()

# Téléverser le fichier PDF
with open("/path/to/document.pdf", "rb") as f:
    file_upload = client.files.upload(file=("document.pdf", f, "application/pdf"))

# Utiliser le fichier téléversé dans un message
message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {"type": "file", "file_id": file_upload.id},
                },
                {"type": "text", "text": "What are the key findings in this document?"},
            ],
        }
    ],
)

print(message.content)

Fonctionnement de la prise en charge des PDF

Lorsque vous envoyez un PDF à Claude, les étapes suivantes se produisent :

  1. Le système extrait le contenu du document.

    • Le système convertit chaque page du document en image.
    • Le texte de chaque page est extrait et fourni avec l’image de chaque page.

  2. Claude analyse à la fois le texte et les images.

    • Les documents sont fournis sous forme de combinaison de texte et d’images pour l’analyse.
    • Cela permet aux utilisateurs de demander des informations sur les éléments visuels d’un PDF, tels que les graphiques, les diagrammes et autres contenus non textuels.

  3. Claude répond, en faisant référence au contenu du PDF si pertinent.

    Claude peut faire référence au contenu textuel comme au contenu visuel lorsqu’il répond. Vous pouvez encore améliorer les performances en intégrant la prise en charge des PDF avec :

Estimer vos coûts

Le nombre de tokens d’un fichier PDF dépend du texte total extrait du document et du nombre de pages :

  • Coûts en tokens de texte : chaque page utilise généralement entre 1 500 et 3 000 tokens selon la densité du contenu. La tarification standard de l’API s’applique, sans frais supplémentaires pour les PDF.
  • Coûts en tokens d’image : étant donné que chaque page est convertie en image, les mêmes calculs de coûts basés sur les images s’appliquent.

Vous pouvez utiliser le comptage de tokens pour estimer les coûts de vos PDF spécifiques.

Optimiser le traitement des PDF

Améliorer les performances

Suivez ces bonnes pratiques pour des résultats optimaux :

  • Placez les PDF avant le texte dans vos requêtes
  • Utilisez des polices standard
  • Assurez-vous que le texte est clair et lisible
  • Faites pivoter les pages dans la bonne orientation verticale
  • Utilisez les numéros de page logiques (du lecteur PDF) dans les prompts
  • Divisez les PDF volumineux en morceaux si nécessaire
  • Activez la mise en cache des prompts pour les analyses répétées

Faire évoluer votre implémentation

Pour le traitement à grand volume, envisagez ces approches :

Utiliser la mise en cache des prompts

Mettez en cache les PDF avec la mise en cache des prompts pour améliorer les performances des requêtes répétées :

import base64
import httpx2

# Tout d'abord, chargez et encodez le PDF.
pdf_url = "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf"
pdf_data = base64.standard_b64encode(
    httpx2.get(pdf_url, follow_redirects=True).content
).decode("utf-8")

# Créez un message avec le document mis en cache.
client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "base64",
                        "media_type": "application/pdf",
                        "data": pdf_data,
                    },
                    "cache_control": {"type": "ephemeral"},
                },
                {
                    "type": "text",
                    "text": "Which model has the highest human preference win rates across each use-case?",
                },
            ],
        }
    ],
)

print(message.content)

Traiter des lots de documents

Utilisez l’API Message Batches pour traiter de nombreux PDF en une seule requête :

import base64
import httpx2

# Tout d'abord, chargez et encodez le PDF.
pdf_url = "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf"
pdf_data = base64.standard_b64encode(
    httpx2.get(pdf_url, follow_redirects=True).content
).decode("utf-8")

# Créez un lot de requêtes qui utilisent le document.
client = anthropic.Anthropic()
message_batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": "my-first-request",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 1024,
                "messages": [
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "document",
                                "source": {
                                    "type": "base64",
                                    "media_type": "application/pdf",
                                    "data": pdf_data,
                                },
                            },
                            {
                                "type": "text",
                                "text": "Which model has the highest human preference win rates across each use-case?",
                            },
                        ],
                    }
                ],
            },
        },
        {
            "custom_id": "my-second-request",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 1024,
                "messages": [
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "document",
                                "source": {
                                    "type": "base64",
                                    "media_type": "application/pdf",
                                    "data": pdf_data,
                                },
                            },
                            {
                                "type": "text",
                                "text": "Extract 5 key insights from this document.",
                            },
                        ],
                    }
                ],
            },
        },
    ]
)

print(message_batch)

Les lots sont traités de manière asynchrone. Pour vérifier la progression et récupérer les résultats une fois le traitement terminé, consultez Traitement par lots.

Étapes suivantes

Vision

Les capacités de vision de Claude lui permettent de traiter et d’analyser des images, ouvrant des possibilités passionnantes pour l’interaction multimodale.

Essayer des exemples de PDF

Explorez des exemples pratiques de traitement de PDF dans la recette du Claude Cookbook.

Consulter la référence de l’API

Consultez la documentation complète de l’API pour la prise en charge des PDF.

Disponibilité

Prise en charge des PDF
API
  • Messages API
  • Managed Agents
Modèles
  • Tous les modèles

Traitement des données

Présentation du traitement des données

Points de terminaison concernés

  • /v1/messages
Zéro conservation des donnéesÉligible

Exclut Modèles couverts

HIPAAÉligible

L’éligibilité HIPAA s’applique aux PDF envoyés directement dans la requête via la Messages API, et non via l’API Files.

Cette page vous a-t-elle été utile ?