Anthropic's financial-services repo: Claude for finance, explained

Large language models can read text — but “reading” an earnings report, a KYC packet, or a regulatory filing is not the same as reading a news article. Financial documents carry dense domain conventions: XBRL tags, Basel III ratios, ISDA schedules, FATF red flags. A general-purpose chatbot can summarize them; a well-engineered Claude integration can extract structured data, flag anomalies, and trigger downstream actions.

The anthropics/financial-services repository ^{[anthropics/financial-services on GitHub]} is Anthropic’s open-source collection of reference implementations — working code templates that show how to wire Claude into financial services workflows correctly. It is not a product you ship to customers. It is a starting kit that answers the question: “What does a production-grade Claude integration for finance actually look like?”

The repository organizes its patterns around three core capability areas:

Document Understanding patterns teach Claude to go beyond summarization. Instead of “this report mentions declining revenue,” the extracted output is { revenue_trend: "declining", pct_change: -12.3, period: "FY2024" } — machine-readable, downstream-usable.

Agentic Workflows patterns use Claude’s tool-use capability. Claude doesn’t just respond to a single prompt; it calls functions (fetch document, run calculation, query database, send alert) and orchestrates a multi-step process. The repo provides the scaffolding for this loop.

Compliance and Risk patterns show how to represent regulatory criteria as prompts or tool definitions, then have Claude evaluate documents against them systematically — with citations back to the specific text that triggered each flag.

Let’s trace a single document — a loan application — through the kind of pipeline the repo enables. The interactive diagram below lets you select a document type and watch which modules activate.

import anthropic
import json

client = anthropic.Anthropic()

# The schema you define becomes the output contract
EXTRACTION_SCHEMA = {
    "type": "object",
    "properties": {
        "company_name": {"type": "string"},
        "fiscal_year": {"type": "integer"},
        "total_revenue_usd": {"type": ["number", "null"]},
        "net_income_usd": {"type": ["number", "null"]},
        "risk_factors": {"type": "array", "items": {"type": "string"}}
    }
}

def extract_from_10k(document_text: str) -> dict:
    response = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"""Extract the following fields from this 10-K filing.
Return ONLY valid JSON matching this schema: {json.dumps(EXTRACTION_SCHEMA)}
If a field cannot be found, use null.

Document:
{document_text}"""
        }]
    )
    return json.loads(response.content[0].text)

The repo extends this pattern significantly — adding retry logic, schema validation, confidence scoring, and multi-document batch processing. But the core is exactly this simple shape.

Practical steps to get started:

1. Clone the repo from github.com/anthropics/financial-services ^{[anthropics/financial-services on GitHub]} .
2. Set your ANTHROPIC_API_KEY environment variable.
3. Browse the examples/ directory — each subdirectory is a self-contained use case with a README.
4. Run the example closest to your use case against a sample document.
5. Adapt the extraction schema to your domain’s specific fields.