How to Integrate Anthropic for payments with Cloudflare Workers for multi-agent systems

Opening

If you’re building multi-agent systems that need to make payment decisions, the useful pattern is simple: let Anthropic handle the reasoning and let Cloudflare Workers handle the edge execution. That gives you a fast, low-latency path for routing payment-related tasks, checking policy, triggering workflows, and keeping the system close to the user.

This integration is a good fit when one agent decides what should happen and Cloudflare Workers executes how it happens at the edge. In practice, that means cleaner orchestration for fraud checks, invoice generation, subscription updates, and payment status callbacks.

Prerequisites

• •Python 3.10+
• •An Anthropic API key
• •A Cloudflare account with:
  • •Workers enabled
  • •A Worker route or test environment configured
• •pip installed
• •httpx for HTTP calls
• •anthropic Python SDK installed
• •cloudflare Python SDK installed
• •Basic familiarity with:
  • •Anthropic Messages API
  • •Cloudflare Workers HTTP endpoints or Worker REST management APIs
• •Environment variables set:
  • •ANTHROPIC_API_KEY
  • •CLOUDFLARE_API_TOKEN
  • •CLOUDFLARE_ACCOUNT_ID

Install dependencies:

pip install anthropic cloudflare httpx python-dotenv

Integration Steps

1) Initialize both clients

Start by loading credentials from environment variables and creating clients for both services. Keep this in one module so your agents can import it cleanly.

import os
from dotenv import load_dotenv
from anthropic import Anthropic
from cloudflare import Cloudflare

load_dotenv()

anthropic_client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
cf_client = Cloudflare(api_token=os.environ["CLOUDFLARE_API_TOKEN"])

ACCOUNT_ID = os.environ["CLOUDFLARE_ACCOUNT_ID"]
WORKER_NAME = "payments-orchestrator"

Use this pattern in production so your agent runtime never hardcodes secrets. If you’re running multiple agents, centralize client creation in a shared config module.

2) Ask Anthropic to decide the payment action

Use Anthropic to classify the request into a structured action. For multi-agent systems, this is where one agent decides whether to authorize, refund, retry, or escalate.

import json

def decide_payment_action(user_message: str) -> dict:
    response = anthropic_client.messages.create(
        model="claude-3-5-sonnet-latest",
        max_tokens=300,
        temperature=0,
        messages=[
            {
                "role": "user",
                "content": f"""
You are a payments routing agent.
Return JSON only with keys:
- action: authorize | refund | retry | escalate
- reason: short string
- amount_cents: integer or null
- currency: string or null

Request: {user_message}
"""
            }
        ],
    )

    text = response.content[0].text
    return json.loads(text)

This keeps the LLM output deterministic enough for downstream automation. In payment flows, don’t let free-form text leak into execution paths.

3) Send the decision to a Cloudflare Worker

Once Anthropic returns a structured decision, forward it to a Worker endpoint. The Worker can then trigger downstream payment logic, update state, or fan out to other agents.

import httpx

def invoke_worker(decision: dict) -> dict:
    worker_url = f"https://{WORKER_NAME}.{ACCOUNT_ID}.workers.dev/api/payments"

    payload = {
        "source": "anthropic-agent",
        "decision": decision,
    }

    with httpx.Client(timeout=15) as client:
        resp = client.post(worker_url, json=payload)
        resp.raise_for_status()
        return resp.json()

In real deployments, your Worker might verify signatures, write to KV/Durable Objects, or publish events to queues. Keep the LLM outside of those side effects; the Worker should be the enforcement point.

4) Orchestrate multiple agents through the Worker

For multi-agent systems, use Cloudflare Workers as the coordination layer. One agent can classify the request while another handles risk scoring or customer support escalation.

def route_multi_agent_task(user_message: str):
    decision = decide_payment_action(user_message)

    if decision["action"] == "escalate":
        return invoke_worker({
            **decision,
            "next_agent": "human-review-agent"
        })

    if decision["action"] == "refund":
        return invoke_worker({
            **decision,
            "next_agent": "refund-execution-agent"
        })

    return invoke_worker({
        **decision,
        "next_agent": "payment-execution-agent"
    })

This pattern scales better than putting all logic inside one prompt. Each agent has one job, and Workers become the durable control plane between them.

5) Deploy or update the Worker from Python

If you manage Workers programmatically, use the Cloudflare SDK to inspect or deploy related resources. The exact deployment flow depends on whether you use Wrangler in CI or direct API calls from Python.

from cloudflare.types.workers.subresources.scripts import ScriptUploadParams

def list_workers_scripts():
    scripts = cf_client.workers.scripts.list(account_id=ACCOUNT_ID)
    return scripts

def upload_worker_script(script_content: str):
    params = ScriptUploadParams(
        body=script_content.encode("utf-8"),
        metadata={
            "main_module": True,
            "compatibility_date": "2024-01-01",
            "bindings": [],
        },
    )

    return cf_client.workers.scripts.update(
        account_id=ACCOUNT_ID,
        script_name=WORKER_NAME,
        script_upload_params=params,
    )

Use this when your platform team wants repeatable infrastructure changes from Python-based tooling. For most teams, CI still owns deployment; Python is better for validation and automation around it.

Testing the Integration

Run an end-to-end check by sending a payment request through Anthropic and then into your Worker.

if __name__ == "__main__":
    result = route_multi_agent_task(
        "Refund $42.50 USD for invoice INV-1042 because duplicate charge was detected."
    )
    print(result)

Expected output:

{
  "status": "ok",
  "received": true,
  "workflow": "refund-execution-agent",
  "decision": {
    "action": "refund",
    "reason": "Duplicate charge detected",
    "amount_cents": 4250,
    "currency": "USD"
  }
}

If this fails, check these first:

• •Anthropic response parsing returned non-JSON text
• •Worker URL is incorrect or not deployed
• •Your Cloudflare token lacks Workers permissions
• •The Worker expects a different payload schema

Real-World Use Cases

• •

  Fraud triage pipeline

  • •Anthropic classifies suspicious payment events.
  • •Cloudflare Workers routes high-risk cases to a review queue with low latency.
• •

  Refund and dispute automation

  • •One agent validates refund eligibility.
  • •Another agent triggers a Worker that updates internal systems and notifies support.
• •

  Subscription lifecycle orchestration

  • •Agents decide whether to retry failed charges, pause accounts, or downgrade plans.
  • •Workers enforce policy at the edge and call billing APIs reliably.

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.