How to Integrate Anthropic for payments with Cloudflare Workers for production AI

Why this integration matters

If you’re building AI agents that move money, the hard part is not the model call. It’s making sure payment actions are controlled, auditable, and run in an environment that can sit close to your users and enforce policy at the edge. Combining Anthropic for payments with Cloudflare Workers gives you a clean split: Anthropic handles the reasoning and payment decisioning, while Workers handle low-latency execution, request validation, and secure routing.

That pattern is useful for checkout assistants, invoice agents, payout workflows, and fraud-aware payment orchestration where you need deterministic execution around an LLM-driven decision.

Prerequisites

• •Python 3.10+
• •anthropic SDK installed
• •cloudflare Python SDK installed
• •A Cloudflare account with Workers enabled
• •An Anthropic API key
• •A Cloudflare API token with Workers permissions
• •A deployed Worker or local Worker development setup using wrangler
• •Basic familiarity with JSON payloads and HTTP requests

Install the Python dependencies:

pip install anthropic cloudflare requests

Set environment variables:

export ANTHROPIC_API_KEY="your_anthropic_key"
export CLOUDFLARE_API_TOKEN="your_cloudflare_token"
export CLOUDFLARE_ACCOUNT_ID="your_account_id"
export WORKER_NAME="payment-agent-worker"

Integration Steps

1. •

   Create the Anthropic client and define the payment tool contract

   In production, don’t let the model invent payment parameters. Define a strict tool schema for payment intent creation or authorization. The model should return structured arguments that your backend can validate before any money movement happens.

import os
from anthropic import Anthropic

client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

tools = [
    {
        "name": "create_payment_intent",
        "description": "Create a payment intent after user approval",
        "input_schema": {
            "type": "object",
            "properties": {
                "amount": {"type": "integer", "minimum": 1},
                "currency": {"type": "string", "enum": ["usd", "eur", "gbp"]},
                "customer_id": {"type": "string"},
                "order_id": {"type": "string"}
            },
            "required": ["amount", "currency", "customer_id", "order_id"]
        }
    }
]

2. •

   Ask Claude to produce a structured payment action

   Use the Messages API and force the model into tool use. This gives you a deterministic handoff from natural language to a machine-readable payment request.

message = client.messages.create(
    model="claude-3-5-sonnet-latest",
    max_tokens=300,
    tools=tools,
    messages=[
        {
            "role": "user",
            "content": (
                "Charge customer cus_123 for order ord_456 "
                "for 4999 cents in USD after confirmation."
            )
        }
    ]
)

tool_use = next(
    block for block in message.content if block.type == "tool_use"
)

print(tool_use.name)
print(tool_use.input)

3. •

   Send the validated payload to a Cloudflare Worker

   Your Worker becomes the enforcement point. It can check signatures, rate limits, idempotency keys, and then call your payments provider or internal ledger service. From Python, invoke it with a standard HTTP request.

import json
import requests

worker_url = f"https://{os.environ['WORKER_NAME']}.workers.dev/payment"

payload = {
    "action": tool_use.name,
    "arguments": tool_use.input,
    "request_id": message.id
}

response = requests.post(
    worker_url,
    headers={
        "Content-Type": "application/json",
        # Add your own HMAC or bearer token here
        "Authorization": f"Bearer {os.environ['CLOUDFLARE_API_TOKEN']}"
    },
    data=json.dumps(payload),
    timeout=15,
)

print(response.status_code)
print(response.json())

4. •

   Deploy or manage the Worker from Python using Cloudflare’s API

   If you want your agent platform to provision Workers automatically per tenant or per environment, use the Cloudflare SDK to inspect account resources and manage deployment metadata around your worker lifecycle.

from cloudflare import Cloudflare

cf = Cloudflare(api_token=os.environ["CLOUDFLARE_API_TOKEN"])

account_id = os.environ["CLOUDFLARE_ACCOUNT_ID"]

workers = cf.workers.scripts.list(account_id=account_id)
for script in workers:
    print(script.id)

# Example: fetch script details if needed for release tracking
script_name = os.environ["WORKER_NAME"]
details = cf.workers.scripts.get(
    script_name=script_name,
    account_id=account_id,
)
print(details)

5. •

   Return the result back into Anthropic for a final user-facing response

   Once Cloudflare finishes the payment operation, feed the result back to Claude so it can generate a clean confirmation message for the user. Keep this separate from execution logic.

worker_result = response.json()

final_message = client.messages.create(
    model="claude-3-5-sonnet-latest",
    max_tokens=200,
    messages=[
        {
            "role": "user",
            "content": (
                f"Payment result: {json.dumps(worker_result)}\n"
                f"Write a short confirmation for the customer."
            )
        }
    ]
)

print(final_message.content[0].text)

Testing the Integration

Use a small dry-run payload first. Your Worker should return a predictable JSON object so you can verify routing, validation, and response handling end to end.

test_payload = {
    "action": "create_payment_intent",
    "arguments": {
        "amount": 4999,
        "currency": "usd",
        "customer_id": "cus_123",
        "order_id": "ord_456"
    },
    "request_id": f"test-{message.id}"
}

r = requests.post(worker_url, json=test_payload, timeout=15)
print(r.status_code)
print(r.json())

Expected output:

{
  "status": 200,
  "payment_intent_id": "pi_01JABC...",
  "state": "authorized",
  "idempotency_key_used": true
}

If this fails, check these first:

• •The Worker URL is reachable from your environment
• •The authorization header matches what your Worker expects
• •The tool arguments match your JSON schema exactly
• •Your Worker returns JSON consistently on success and failure

Real-World Use Cases

• •Checkout assistant: Claude interprets user intent, then Workers validate order totals and create a payment intent only after explicit approval.
• •Invoice collection agent: An AI agent reads overdue invoices, drafts reminders, and triggers retry logic through a Worker after policy checks.
• •Payout orchestration: Route approved vendor payouts through Workers while Claude handles exception handling, summarization, and operator-facing explanations.

The production pattern here is simple: let Anthropic decide what should happen, let Cloudflare Workers decide whether it is allowed to happen right now. That separation keeps your agent system fast enough for real users and strict enough for payments work.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.