Supporto PDF

This feature is eligible for Zero Data Retention (ZDR). When your organization has a ZDR arrangement, data sent through this feature is not stored after the API response is returned.

Puoi chiedere a Claude informazioni su qualsiasi testo, immagine, grafico e tabella nei PDF che fornisci. Alcuni casi d'uso di esempio:

Analizzare rapporti finanziari e comprendere grafici/tabelle
Estrarre informazioni chiave da documenti legali
Assistenza nella traduzione di documenti
Convertire informazioni da documenti in formati strutturati

Prima di iniziare

Verifica i requisiti PDF

Claude funziona con qualsiasi PDF standard. Assicurati che la dimensione della tua richiesta soddisfi questi requisiti:

Requisito	Limite
Dimensione massima della richiesta	32 MB (varia in base alla piattaforma)
Pagine massime per richiesta	600 (100 per modelli con finestra di contesto da 200k token)
Formato	PDF standard (senza password/crittografia)

Entrambi i limiti si applicano all'intero payload della richiesta, incluso qualsiasi altro contenuto inviato insieme ai PDF. Per PDF di grandi dimensioni, considera il caricamento con l'API Files e il riferimento tramite file_id per mantenere i payload delle richieste piccoli.

I PDF densi (molte pagine con caratteri piccoli, tabelle complesse o grafica pesante) possono riempire la finestra di contesto prima di raggiungere il limite di pagine. Le richieste con PDF di grandi dimensioni possono anche fallire prima di raggiungere il limite di pagine, anche quando si utilizza l'API Files. Prova a dividere il documento in sezioni; per file di grandi dimensioni, poiché ogni pagina viene elaborata come un'immagine, il downsampling delle immagini incorporate può anche aiutare.

Poiché il supporto PDF si basa sulle capacità di visione di Claude, è soggetto alle stesse limitazioni e considerazioni di altri compiti di visione.

Piattaforme e modelli supportati

Il supporto PDF è attualmente supportato tramite accesso API diretto e Google Vertex AI. Tutti i modelli attivi supportano l'elaborazione PDF.

Il supporto PDF è ora disponibile su Amazon Bedrock con le seguenti considerazioni:

Supporto PDF di Amazon Bedrock

Quando si utilizza il supporto PDF tramite l'API Converse di Amazon Bedrock, ci sono due modalità di elaborazione dei documenti distinte:

Importante: Per accedere alle capacità complete di comprensione visiva dei PDF di Claude nell'API Converse, devi abilitare le citazioni. Senza le citazioni abilitate, l'API ricade nell'estrazione di testo di base solamente. Scopri di più su come lavorare con le citazioni.

Modalità di elaborazione dei documenti

Converse Document Chat (Modalità originale - Solo estrazione di testo)
- Fornisce estrazione di testo di base dai PDF
- Non può analizzare immagini, grafici o layout visivi all'interno dei PDF
- Utilizza approssimativamente 1.000 token per un PDF di 3 pagine
- Utilizzato automaticamente quando le citazioni non sono abilitate
Claude PDF Chat (Nuova modalità - Comprensione visiva completa)
- Fornisce analisi visiva completa dei PDF
- Può comprendere e analizzare grafici, diagrammi, immagini e layout visivi
- Elabora ogni pagina sia come testo che come immagine per una comprensione completa
- Utilizza approssimativamente 7.000 token per un PDF di 3 pagine

Limitazioni chiave

API Converse: L'analisi visiva dei PDF richiede l'abilitazione delle citazioni. Attualmente non esiste un'opzione per utilizzare l'analisi visiva senza citazioni (a differenza dell'API InvokeModel).
API InvokeModel: Fornisce il controllo completo sull'elaborazione dei PDF senza citazioni forzate.

Problemi comuni

Se i clienti segnalano che Claude non vede immagini o grafici nei loro PDF quando utilizza l'API Converse, probabilmente devono abilitare il flag delle citazioni. Senza di esso, Converse ricade nell'estrazione di testo di base solamente.

Questo è un vincolo noto dell'API Converse. Per le applicazioni che richiedono l'analisi visiva dei PDF senza citazioni, considera l'utilizzo dell'API InvokeModel.

Per file non PDF come .csv, .xlsx, .docx, .md o .txt, vedi Lavorare con altri formati di file.

Elabora PDF con Claude

Invia la tua prima richiesta PDF

Iniziamo con un semplice esempio utilizzando l'API Messages. Puoi fornire PDF a Claude in tre modi:

Come riferimento URL a un PDF ospitato online
Come PDF codificato in base64 nei blocchi di contenuto document
Per file_id dall'API Files

Opzione 1: Documento PDF basato su URL

L'approccio più semplice è fare riferimento a un PDF direttamente da un URL:

Opzione 2: Documento PDF codificato in base64

Se hai bisogno di inviare PDF dal tuo sistema locale o quando un URL non è disponibile:

Opzione 3: API Files

Per i PDF che utilizzerai ripetutamente, o quando vuoi evitare il sovraccarico di codifica, utilizza l'API Files:

Come funziona il supporto PDF

Quando invii un PDF a Claude, si verificano i seguenti passaggi:

Il sistema estrae il contenuto del documento.
- Il sistema converte ogni pagina del documento in un'immagine.
- Il testo di ogni pagina viene estratto e fornito insieme all'immagine di ogni pagina.
Claude analizza sia il testo che le immagini per comprendere meglio il documento.
- I documenti vengono forniti come una combinazione di testo e immagini per l'analisi.
- Questo consente agli utenti di chiedere informazioni su elementi visivi di un PDF, come grafici, diagrammi e altri contenuti non testuali.
Claude risponde, facendo riferimento ai contenuti del PDF se rilevante.
Claude può fare riferimento sia al contenuto testuale che visivo quando risponde. Puoi migliorare ulteriormente le prestazioni integrando il supporto PDF con:
- Prompt caching: Per migliorare le prestazioni per l'analisi ripetuta.
- Batch processing: Per l'elaborazione di documenti ad alto volume.
- Tool use: Per estrarre informazioni specifiche dai documenti da utilizzare come input degli strumenti.

Stima i tuoi costi

Il conteggio dei token di un file PDF dipende dal testo totale estratto dal documento e dal numero di pagine:

Costi dei token di testo: Ogni pagina utilizza in genere 1.500-3.000 token per pagina a seconda della densità del contenuto. Si applica il prezzo API standard senza commissioni aggiuntive per i PDF.
Costi dei token di immagine: Poiché ogni pagina viene convertita in un'immagine, si applicano gli stessi calcoli dei costi basati su immagini.

Puoi utilizzare il conteggio dei token per stimare i costi per i tuoi PDF specifici.

Ottimizza l'elaborazione PDF

Migliora le prestazioni

Segui queste best practice per risultati ottimali:

Posiziona i PDF prima del testo nelle tue richieste
Utilizza caratteri standard
Assicurati che il testo sia chiaro e leggibile
Ruota le pagine nell'orientamento verticale corretto
Utilizza numeri di pagina logici (dal visualizzatore PDF) nei prompt
Dividi i PDF di grandi dimensioni in blocchi quando necessario
Abilita il prompt caching per l'analisi ripetuta

Scalare la tua implementazione

Per l'elaborazione ad alto volume, considera questi approcci:

Usa la cache dei prompt

Memorizza nella cache i PDF per migliorare le prestazioni su query ripetute:

Elabora batch di documenti

Utilizza l'API Message Batches per flussi di lavoro ad alto volume:

Passaggi successivi

Prova gli esempi PDF

Esplora esempi pratici di elaborazione PDF nella ricetta del cookbook.

client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-opus-4-7",
    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)

import base64
import httpx

# First, load and encode the PDF
pdf_url = "https://assets.anthropic.com/m/1cd9d098ac3e6467/original/Claude-3-Model-Card-October-Addendum.pdf"
pdf_data = base64.standard_b64encode(httpx.get(pdf_url).content).decode("utf-8")

# Alternative: Load from a local file
# with open("document.pdf", "rb") as f:
#     pdf_data = base64.standard_b64encode(f.read()).decode("utf-8")

# Send to Claude using base64 encoding
client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-opus-4-7",
    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)

client = anthropic.Anthropic()

# Upload the PDF file
with open("document.pdf", "rb") as f:
    file_upload = client.beta.files.upload(file=("document.pdf", f, "application/pdf"))

# Use the uploaded file in a message
message = client.beta.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    betas=["files-api-2025-04-14"],
    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)

client = anthropic.Anthropic()
# ...
message = client.messages.create(
    model="claude-opus-4-7",
    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": "Analyze this document."},
            ],
        }
    ],
)

client = anthropic.Anthropic()
# ...
message_batch = client.messages.batches.create(
    requests=[
        {
            "custom_id": "doc1",
            "params": {
                "model": "claude-opus-4-7",
                "max_tokens": 1024,
                "messages": [
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "document",
                                "source": {
                                    "type": "base64",
                                    "media_type": "application/pdf",
                                    "data": pdf_data,
                                },
                            },
                            {"type": "text", "text": "Summarize this document."},
                        ],
                    }
                ],
            },
        }
    ]
)