Claude + Notion Integration: Knowledge Management AI Augmentation

Why Notion's Built-in AI Falls Short for Enterprise Knowledge Management

Notion's native AI features—auto-completion, summary generation, and basic content creation—work fine for individual use. They're convenient. They're safe. And they're fundamentally limited for enterprise knowledge management at scale.

Here's the gap: Notion AI operates inside Notion's sandbox. It can rewrite a paragraph or summarize a page. It cannot extract structured data from unrelated databases, correlate information across 50 Notion workspaces, or apply deep domain logic to your proprietary knowledge. It cannot reason about the relationships between your customer knowledge base, internal documentation, and project history simultaneously.

Claude + Notion integration changes this. You're not replacing Notion's database capabilities. You're augmenting them with Claude's reasoning, your business rules, and cross-domain knowledge synthesis. A Claude Notion integration lets you build intelligent systems that treat your Notion workspace as a structured knowledge engine rather than a static content repository.

The barrier to this integration is technical—not conceptual. The Notion API is mature and well-documented. Claude's API accepts text, runs on any infrastructure you control, and can orchestrate workflows at enterprise scale. The integration layer is where the difficulty lies, which is why Claude API integration services are purpose-built for teams without dedicated AI engineering resources.

Real-World Use Cases: What Claude Notion Integration Enables

The most successful Claude Notion integrations solve specific, high-value problems. These aren't academic exercises. They're systems generating thousands of dollars in team productivity per month.

Automated Wiki Creation from Meeting Notes and Documents

Your team holds a product strategy meeting. Decisions are made, technical debt is acknowledged, roadmap items are discussed. The meeting transcript and supporting documents land in a Notion folder.

A Claude + Notion workflow automatically:

• Reads all meeting documents via the Notion API
• Extracts decisions, commitments, and context via Claude
• Generates a structured wiki entry with decision rationale, owners, and follow-up actions
• Publishes the wiki entry to your Notion knowledge base automatically
• Tags the entry with related projects and people via database relations

Result: Your team stops maintaining separate decision logs. Notion becomes the single source of truth for organizational decisions, augmented by Claude's ability to extract signal from noise.

Database-Driven Document Generation

Your customer success team manages client data in Notion: contract terms, deployment dates, custom requirements, usage patterns. When a customer requests a project briefing document, it's currently built manually from scattered Notion tables.

Claude Notion integration enables a system that:

• Queries the customer's Notion database record
• Fetches related contract data, deployment notes, and historical updates
• Sends all structured data to Claude with a project briefing template
• Claude generates a tailored briefing document with context-specific insights
• Stores the briefing back in Notion with proper relational linking

This eliminates hours of manual document assembly. It ensures consistency. It makes historical briefings searchable and updateable.

Intelligent Search Across Notion Workspaces

Your enterprise has 15 Notion workspaces: one per team, plus shared spaces. A user asks: "What decisions have we made about authentication architecture?" Notion's native search finds pages with those keywords. Claude Notion integration finds the actual decisions—across workspaces, databases, and document types—with reasoning about context and relevance.

Claude can understand intent. "Authentication architecture" isn't just a text string to match; it's a concept. Claude retrieves documents about OAuth, SSO, session management, credential storage, and API keys—then synthesizes answers based on your actual organizational decisions.

Automated Project Briefing Creation

When a project launches, stakeholders need a briefing: scope, timeline, budget, key dependencies, stakeholders, risks. Instead of a project manager compiling this from email threads and Notion scattered notes, Claude Notion integration can:

• Fetch the project record from your Notion projects database
• Query dependent records: team assignments, budget allocations, milestone dates
• Pull related documents: requirements, technical specs, stakeholder notes
• Ask Claude to synthesize a comprehensive briefing with identified risks and dependencies
• Automatically publish as a Notion page linked to the project record

Knowledge Gap Analysis

Claude can analyze your Notion knowledge base and identify gaps. Ask Claude to review your onboarding documentation, technical standards, and process guides. Claude identifies:

• Topics mentioned but never explained
• Processes documented inconsistently across teams
• Critical domain knowledge that exists only in a single person's private notes
• Outdated information still in your knowledge base

Claude can then generate drafts of missing documentation, enabling your team to focus on review and refinement rather than starting from scratch.

Cross-Database Reporting and Synthesis

Finance tracks budgets. Operations tracks resource allocation. Engineering tracks project spending. These live in three separate Notion databases. A real-time spending report requires manually pulling data from all three, then writing synthesis.

Claude Notion integration can:

• Query all three databases automatically
• Correlate spending by project, department, and budget line
• Generate monthly spending reports with anomalies highlighted
• Flag budgets exceeding thresholds and recommend actions

This runs on a schedule. Your finance team has updated spending insights every morning without manual compilation.

Two Paths: API Middleware vs MCP Server Architecture

Claude Notion integration can be built two ways, each with distinct tradeoffs. Your choice depends on scale, security requirements, and existing infrastructure.

Approach 1: Notion API + Claude API with Python/Node.js Middleware

This is the traditional integration pattern. You build a service—deployed on Lambda, Docker, or your own servers—that:

• Receives triggers (webhook from Notion, scheduled task, user request)
• Calls the Notion API to fetch data structures (databases, pages, blocks)
• Formats the retrieved data as context
• Sends context + task prompt to Claude API
• Processes Claude's response
• Writes results back to Notion via API

Advantages: Complete control over the workflow. You define exactly which Notion data is accessed and when. Familiar architecture for teams with existing backend infrastructure. Easy to add business logic, error handling, and retry logic specific to your use case.

Disadvantages: You're responsible for maintaining the middleware service. API rate limiting and cost management require explicit code. Error handling across three systems (your app, Notion API, Claude API) adds complexity.

Approach 2: MCP Server for Notion (Model Context Protocol)

MCP (Model Context Protocol) is Anthropic's framework for connecting Claude to external systems. An MCP server for Notion exposes Notion's capabilities as tools that Claude can call directly. You configure Claude with the Notion MCP server, and Claude can autonomously fetch and write Notion data as needed during conversations.

This works inside Claude's tools ecosystem. You don't build middleware; you deploy an MCP server, configure it with your Notion API key, and Claude handles the integration orchestration.

Advantages: Minimal infrastructure. Claude manages the reasoning about when and what Notion data to fetch. Great for chat-based workflows and one-off automation. Faster time-to-value.

Disadvantages: Less explicit control. Token usage is less predictable because Claude decides how much Notion data to fetch. Not ideal for high-scale, repetitive tasks where you need strict cost management. Limited ability to run complex multi-step workflows triggered by external events.

Which Path Is Right?

Use API Middleware if you need: predictable costs, high-volume automation, strict control over which data is accessed, integration with your existing infrastructure, complex conditional logic.

Use MCP Server if you need: fast implementation, interactive Claude workflows, flexibility for ad-hoc queries, or you're already using Claude via API for other tasks.

Many mature deployments use both. An MCP server for interactive exploration and data access. API middleware for scheduled, high-volume automations where cost and control matter.

Building Claude + Notion Integration with API Middleware

Here's a complete walkthrough of building a Claude Notion integration using Python. This example builds an automated wiki generator: feed it meeting notes and documents, and it generates a structured wiki entry in Notion.

Prerequisites

• Notion API key (from Notion integrations dashboard)
• Claude API key (from Anthropic)
• A Notion database configured to store wiki entries
• Python 3.10+, requests library, anthropic SDK

Step 1: Fetch Data from Notion

The Notion API uses database queries to retrieve structured data. Here's how to fetch documents from a meeting notes database:

import requests
import json

NOTION_API_KEY = "your-notion-api-key"
DATABASE_ID = "your-database-id"  # Without dashes
NOTION_API_URL = "https://api.notion.com/v1"

def query_notion_database(database_id, filter_params=None):
    """Query a Notion database and return results."""
    headers = {
        "Authorization": f"Bearer {NOTION_API_KEY}",
        "Notion-Version": "2022-06-28",
        "Content-Type": "application/json"
    }

    url = f"{NOTION_API_URL}/databases/{database_id}/query"

    payload = {
        "filter": filter_params or {},
        "page_size": 100
    }

    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    return response.json()

# Fetch all meeting notes from the last 7 days
results = query_notion_database(DATABASE_ID)
meeting_documents = results.get("results", [])

Step 2: Extract Block Content from Pages

Notion pages are composed of blocks. To get the actual content, you need to fetch blocks from each page:

def get_page_blocks(page_id):
    """Retrieve all blocks from a Notion page."""
    headers = {
        "Authorization": f"Bearer {NOTION_API_KEY}",
        "Notion-Version": "2022-06-28"
    }

    url = f"{NOTION_API_URL}/blocks/{page_id}/children"
    blocks = []
    has_more = True
    start_cursor = None

    while has_more:
        params = {"page_size": 100}
        if start_cursor:
            params["start_cursor"] = start_cursor

        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()
        data = response.json()

        blocks.extend(data.get("results", []))
        has_more = data.get("has_more", False)
        start_cursor = data.get("next_cursor")

    return blocks

def extract_text_from_blocks(blocks):
    """Convert Notion blocks to plain text."""
    text_content = []

    for block in blocks:
        block_type = block.get("type")
        block_data = block.get(block_type, {})

        if block_type == "paragraph":
            rich_text = block_data.get("rich_text", [])
            text = "".join([t.get("plain_text", "") for t in rich_text])
            if text.strip():
                text_content.append(text)

        elif block_type == "heading_1":
            text = "".join([t.get("plain_text", "") for t in block_data.get("rich_text", [])])
            text_content.append(f"# {text}")

        elif block_type == "heading_2":
            text = "".join([t.get("plain_text", "") for t in block_data.get("rich_text", [])])
            text_content.append(f"## {text}")

        elif block_type == "bulleted_list_item":
            text = "".join([t.get("plain_text", "") for t in block_data.get("rich_text", [])])
            text_content.append(f"• {text}")

        elif block_type == "callout":
            text = "".join([t.get("plain_text", "") for t in block_data.get("rich_text", [])])
            emoji = block_data.get("icon", {}).get("emoji", "ℹ")
            text_content.append(f"{emoji} {text}")

    return "\n".join(text_content)

# Example usage
page_id = meeting_documents[0]["id"]
blocks = get_page_blocks(page_id)
content = extract_text_from_blocks(blocks)

Step 3: Send to Claude for Processing

Now you have structured content from Notion. Send it to Claude with a task prompt:

from anthropic import Anthropic

client = Anthropic()

def generate_wiki_entry(meeting_content):
    """Use Claude to generate a wiki entry from meeting notes."""

    prompt = f"""You are a technical documentation expert. Extract key information
from these meeting notes and generate a structured wiki entry.

Meeting Notes:
{meeting_content}

Generate a wiki entry with these sections:
1. Summary (2-3 sentences)
2. Decisions Made (bullet points)
3. Action Items (with owners and due dates)
4. Technical Context (if applicable)
5. Related Topics (list of related concepts)

Format as structured text suitable for publishing to a wiki."""

    message = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2000,
        messages=[
            {"role": "user", "content": prompt}
        ]
    )

    return message.content[0].text

# Generate the wiki entry
wiki_content = generate_wiki_entry(content)

Step 4: Write Back to Notion

Create a new page in your wiki database with the generated content:

def create_notion_page(database_id, title, content):
    """Create a new page in a Notion database."""
    headers = {
        "Authorization": f"Bearer {NOTION_API_KEY}",
        "Notion-Version": "2022-06-28",
        "Content-Type": "application/json"
    }

    # Split content into blocks
    paragraphs = content.split("\n\n")
    children = []

    for para in paragraphs:
        if para.startswith("#"):
            # Heading block
            heading_text = para.lstrip("#").strip()
            children.append({
                "object": "block",
                "type": "heading_2",
                "heading_2": {
                    "rich_text": [{"type": "text", "text": {"content": heading_text}}],
                    "is_toggleable": False
                }
            })
        elif para.startswith("•"):
            # Bullet point
            bullet_text = para.lstrip("•").strip()
            children.append({
                "object": "block",
                "type": "bulleted_list_item",
                "bulleted_list_item": {
                    "rich_text": [{"type": "text", "text": {"content": bullet_text}}]
                }
            })
        else:
            # Regular paragraph
            children.append({
                "object": "block",
                "type": "paragraph",
                "paragraph": {
                    "rich_text": [{"type": "text", "text": {"content": para}}]
                }
            })

    payload = {
        "parent": {"database_id": database_id},
        "properties": {
            "Title": {
                "title": [{"type": "text", "text": {"content": title}}]
            },
            "Status": {
                "status": {"name": "Published"}
            }
        },
        "children": children
    }

    url = f"{NOTION_API_URL}/pages"
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    return response.json()

# Create the wiki page
wiki_title = f"Meeting Notes - {meeting_documents[0]['properties']['Date']['date']['start']}"
new_page = create_notion_page(DATABASE_ID, wiki_title, wiki_content)

Notion Block Types Supported for Creation

When writing back to Notion, use these block types for reliable rendering:

MCP Server Integration: Notion Tools for Claude

If you're using Claude Code or Claude API directly, the MCP (Model Context Protocol) approach is simpler. Deploy an MCP server that exposes Notion tools, and Claude can interact with your workspace autonomously.

Setting Up the Notion MCP Server

The open-source Notion MCP server is maintained by the community. Install it in your Claude Code environment:

# Using Claude Code or similar MCP environments
npm install @modelcontextprotocol/server-notion

# Set environment variable
export NOTION_API_KEY="your-api-key"

# Start the server
node node_modules/@modelcontextprotocol/server-notion/dist/index.js

What Claude Can Do with Notion MCP

Once configured, Claude gains these capabilities:

• Query databases: "Fetch all customer records with an upcoming renewal date"
• Read page content: "Summarize the engineering standards document"
• Create pages: "Generate a project briefing and add it to the projects database"
• Update properties: "Mark all completed tasks as done"
• Search content: "Find all pages mentioning OAuth configuration"

Example: Interactive Document Generation

With MCP, you can ask Claude to generate documents on demand:

I need a quarterly report. Please:
1. Query the quarterly_metrics database for Q1 2026 data
2. Fetch the strategic_goals page to understand priorities
3. Retrieve the team_budget database to correlate spending
4. Generate a comprehensive quarterly report with key metrics,
   progress against goals, budget analysis, and recommendations
5. Create a new page in the reports database with the report

Claude will automatically fetch the required data, synthesize insights, and write back to Notion—all without any middleware code from you.

MCP vs API Middleware Trade-offs

MCP excels at interactive workflows and rapid prototyping. But at enterprise scale, API middleware gives you:

• Precise cost control (you know exactly what data is fetched)
• Deterministic scheduling (run at specific times)
• Complex conditional logic (if X condition, do Y, else do Z)
• Error handling and retry logic specific to your use case
• Compliance and audit logs for regulated industries

Many teams deploy MCP for exploration and ad-hoc tasks, then productionize successful workflows as API middleware services.

Notion Database Schema Design for AI-Augmented Workflows

The structure of your Notion databases directly impacts how well Claude can reason about and manipulate your data. Here's how to design schemas that work well with Claude integration.

Database Property Types for AI Workflows

Choose property types that provide structure. Claude works better with typed data than with free-form text:

Example: Knowledge Base Database Schema

For a knowledge base that Claude will query and augment, structure it like this:

Database: Knowledge Base Articles

Properties:
- Title (text) → Article title
- Content (text) → Full article body (Claude processes this)
- Category (select) → Infrastructure, Security, Process, Product
- Status (status) → Draft, Published, Archived
- Topics (multi-select) → Tags for cross-linking (Claude generates these)
- Author (person) → Who wrote it
- Last Updated (date) → Maintenance tracking
- Related Articles (relation) → Links to related knowledge base entries
- Readership Score (number) → How many views/relevance (Claude can use this to rank)
- AI Generated (checkbox) → Whether Claude generated this

Database Relations for Context Enrichment

Use relation properties to help Claude understand connections between your data:

Projects Database
├─ Project Name (text)
├─ Status (select)
├─ Team Members (relation → People)
├─ Budget (number)
├─ Related Documents (relation → Documents)
└─ Dependent Projects (relation → Projects)

Documents Database
├─ Title (text)
├─ Content (text)
├─ Document Type (select)
├─ Related Projects (relation → Projects)
└─ Version (number)

When Claude fetches a project, it can also retrieve team members and related documents in the same query. This provides rich context for reasoning and content generation.

Filtering for AI Workflows

The Notion API uses filter objects to query databases. Here's how to structure queries Claude will execute:

{
  "filter": {
    "and": [
      {
        "property": "Status",
        "select": {
          "equals": "Active"
        }
      },
      {
        "property": "Team",
        "relation": {
          "contains": "Engineering"
        }
      }
    ]
  }
}

Complex filters with multiple AND/OR conditions enable Claude to fetch exactly the data needed for a task, reducing context size and cost.

Handling Large Documents and Context Window Management

Notion workspaces can contain gigabytes of content. Claude has a context window (the amount of text it can process in one request). Integrate successfully by being strategic about what you fetch.

Context Window Limits

Claude's context windows vary by model version. As of 2026, typical limits are 200K tokens (roughly 150,000 words). A large Notion document library can exceed this quickly.

Strategies for Large Data Sets

1. Summarize Before Sending to Claude

Don't send entire documents. Extract summaries and key facts:

def extract_summary_from_notion_page(page_id):
    """Get key information from a page without full content."""
    blocks = get_page_blocks(page_id)

    # Extract only first paragraph, headings, and callout blocks
    summary_blocks = []
    for block in blocks[:20]:  # First 20 blocks only
        if block["type"] in ["paragraph", "heading_1", "heading_2", "callout"]:
            summary_blocks.append(block)

    return summary_blocks

2. Filter by Relevance

Query only data matching your task criteria:

# Instead of fetching all 500 documents,
# fetch only documents updated in the last 30 days
query_payload = {
    "filter": {
        "property": "Last Updated",
        "date": {
            "past_week": {}
        }
    }
}

3. Chunk Large Documents

For a document larger than the context window, split it and process incrementally:

def chunk_content(content, chunk_size=5000):
    """Split content into chunks of approximately chunk_size characters."""
    chunks = []
    words = content.split()
    current_chunk = []
    current_size = 0

    for word in words:
        current_chunk.append(word)
        current_size += len(word) + 1

        if current_size >= chunk_size:
            chunks.append(" ".join(current_chunk))
            current_chunk = []
            current_size = 0

    if current_chunk:
        chunks.append(" ".join(current_chunk))

    return chunks

# Process each chunk with Claude
chunks = chunk_content(large_document)
summaries = []

for i, chunk in enumerate(chunks):
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=500,
        messages=[
            {"role": "user", "content": f"Summarize this section (part {i+1}/{len(chunks)}):\n{chunk}"}
        ]
    )
    summaries.append(response.content[0].text)

# Combine summaries
full_summary = "\n".join(summaries)

4. Use Database Relations for Efficient Queries

Instead of fetching entire documents, use Notion's relational properties to get structured metadata:

# Efficient: Fetch only the metadata you need
metadata_query = {
    "database_id": "projects_db",
    "filter": {"property": "Status", "select": {"equals": "Active"}},
    # Only fetch these properties, not full page content
    "properties": ["Title", "Owner", "Budget", "Deadline"]
}

# Inefficient: Fetch full page content for all projects
# (Each page fetch requires an additional API call)

Token Budget Planning

When designing your integration, estimate tokens:

• Average English: 1 token ≈ 4 characters ≈ 0.75 words
• Code: 1 token ≈ 2 characters (denser)
• Prompt: "Summarize this: [50KB of content]" ≈ 12,500 tokens

If your workflow needs 50MB of Notion data summarized regularly, you might break it into daily summarization tasks (more API calls, but each stays within context limits) rather than trying to process everything in one go.

Caching Strategy

Cache summaries and derived data back to Notion:

def store_claude_summary(notion_page_id, summary, created_by="Claude"):
    """Store Claude's summary in Notion to avoid re-processing."""
    headers = {
        "Authorization": f"Bearer {NOTION_API_KEY}",
        "Notion-Version": "2022-06-28",
        "Content-Type": "application/json"
    }

    payload = {
        "properties": {
            "AI Summary": {
                "rich_text": [{"type": "text", "text": {"content": summary}}]
            },
            "Summary Updated": {
                "date": {"start": datetime.now().isoformat()}
            }
        }
    }

    url = f"{NOTION_API_URL}/pages/{notion_page_id}"
    response = requests.patch(url, headers=headers, json=payload)
    return response.json()

On the next query, check if a summary already exists. If it's recent, skip re-processing. This cuts costs dramatically for repetitive tasks.

Security, Governance, and Enterprise Considerations

When Claude directly accesses your Notion workspace—especially in regulated industries—governance becomes critical. Here's how to implement this safely.

API Key Management

Never hardcode API keys. Use environment variables or secrets management:

# ✅ Correct: Environment variable
notion_key = os.environ.get("NOTION_API_KEY")
claude_key = os.environ.get("ANTHROPIC_API_KEY")

# ❌ Wrong: Hardcoded
notion_key = "ntn_aB1234..."  # Don't do this

For production systems, use a secrets manager:

• AWS Secrets Manager: For Lambda-based integrations
• Kubernetes Secrets: For containerized deployments
• HashiCorp Vault: For multi-service environments
• Azure Key Vault: For Microsoft ecosystems

Notion API Permissions: What Each Key Can Access

Notion API keys are all-or-nothing in terms of workspace access, but you control which capabilities are enabled. When creating an integration in Notion:

• Read content: Required to fetch pages, databases, and blocks
• Update content: Required to create/modify pages and properties
• Insert content: Required to add blocks to existing pages
• Delete content: Keep disabled unless you need to delete pages

For a read-only integration (e.g., indexing documents for search), disable all write capabilities. For automated wiki generation, enable read, update, and insert.

Content Policy and Compliance

Before using Claude to process your Notion content, review what can be done:

Claude's Acceptable Use Policy

• Allowed: Summarizing internal documents, generating business content from your data, analyzing structured databases
• Not allowed: Processing personally identifiable information (PII) for non-business purposes, generating content intended to deceive, analyzing for discrimination
• Caution: Medical/legal data may have special requirements; review Anthropic's compliance documentation

Data Residency

Notion and Claude API handle data in different regions. For GDPR or other regulatory compliance:

• Verify Claude API meets your data residency requirements (Anthropic has EU and US regions)
• Notion EU instances have specific data handling commitments
• Document the data flow: Notion → Your middleware → Claude API → Result
• Include this flow in your data processing agreements if required

Enterprise Notion vs Team Plan Differences

Notion's pricing tiers affect API capabilities:

For regulated industries or compliance-heavy deployments, Enterprise Notion + audit logging + role-based access control is necessary to demonstrate proper governance of your integration.

Monitoring and Logging

Log all Claude-to-Notion interactions for audit and debugging:

import logging
import json
from datetime import datetime

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("claude-notion-integration")

def log_integration_event(event_type, page_id, status, details):
    """Log integration events for audit trail."""
    log_entry = {
        "timestamp": datetime.utcnow().isoformat(),
        "event_type": event_type,  # "fetch", "process", "write", "error"
        "page_id": page_id,
        "status": status,  # "success", "failure", "partial"
        "details": details
    }
    logger.info(json.dumps(log_entry))

# Example usage
try:
    wiki_content = generate_wiki_entry(meeting_content)
    log_integration_event("process", page_id, "success", {
        "input_length": len(meeting_content),
        "output_length": len(wiki_content),
        "model": "claude-3-5-sonnet"
    })
except Exception as e:
    log_integration_event("process", page_id, "failure", {"error": str(e)})

Store logs in a system you can query and archive (CloudWatch for AWS, Splunk, or any centralized logging platform). For compliance audits, these logs prove what data was accessed, when, and by what system.

Rate Limiting and Cost Management

Both Notion and Claude APIs have rate limits. Respect them to avoid outages:

• Notion API: 3 requests/second per integration (burst to 60 over time)
• Claude API: Rate limits based on your plan; implement exponential backoff

import time
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(5),
    wait=wait_exponential(multiplier=1, min=2, max=10)
)
def call_claude_api_with_retry(prompt):
    """Call Claude with automatic retry and exponential backoff."""
    return client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2000,
        messages=[{"role": "user", "content": prompt}]
    )

# If Claude returns a rate limit error, this will wait 2, 4, 8, 16 seconds
# before retrying, up to 5 attempts.

Track your actual API costs. Claude charges per input/output tokens. Budget aggressively when you're experimenting, then optimize once you understand your actual token consumption.