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

Combining Anthropic for healthcare with Cloudflare Workers gives you a clean production path for regulated AI workflows: model reasoning stays strong, while request handling, routing, and edge execution stay close to the user. For healthcare systems, that means lower latency for triage and summarization, plus a better place to enforce auth, rate limits, logging, and PHI-aware controls before anything reaches the model.

Prerequisites

• •Python 3.10+
• •An Anthropic API key with access to the healthcare use case you’re targeting
• •A Cloudflare account
• •A deployed Cloudflare Worker
• •wrangler installed and authenticated
• •Environment variables set:
  • •ANTHROPIC_API_KEY
  • •CLOUDFLARE_ACCOUNT_ID
  • •CLOUDFLARE_API_TOKEN
• •requests installed for Python client calls
• •Basic familiarity with:
  • •Anthropic Messages API
  • •Cloudflare Workers Fetch API

Integration Steps

1. •Set up your Python project and install dependencies.

python -m venv .venv
source .venv/bin/activate

pip install anthropic requests python-dotenv

Use a .env file locally so you do not hardcode secrets in code.

ANTHROPIC_API_KEY=your_anthropic_key
CLOUDFLARE_ACCOUNT_ID=your_cloudflare_account_id
CLOUDFLARE_API_TOKEN=your_cloudflare_api_token
WORKER_URL=https://your-worker.your-subdomain.workers.dev

2. •Call Anthropic directly from Python for the healthcare task.

This is the core model call. In a production setup, your Worker can sit in front of this call or proxy it depending on your architecture.

import os
from anthropic import Anthropic

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

response = client.messages.create(
    model="claude-3-5-sonnet-latest",
    max_tokens=300,
    temperature=0,
    messages=[
        {
            "role": "user",
            "content": (
                "Summarize this clinical note for a care coordinator. "
                "Remove identifiers and keep only clinically relevant facts:\n\n"
                "Patient reports chest tightness after exertion. "
                "History of hypertension and type 2 diabetes. "
                "Recommended ECG and follow-up within 48 hours."
            ),
        }
    ],
)

print(response.content[0].text)

For healthcare workloads, keep temperature low and constrain output to the minimum needed for downstream use.

3. •Put Cloudflare Workers in front as an edge gateway.

A common pattern is: client → Worker → Anthropic. The Worker handles auth, input validation, PHI filtering, and request shaping before forwarding the prompt.

Example Worker code:

export default {
  async fetch(request, env) {
    if (request.method !== "POST") {
      return new Response("Method not allowed", { status: 405 });
    }

    const body = await request.json();
    const prompt = body.prompt;

    if (!prompt || typeof prompt !== "string") {
      return new Response("Invalid payload", { status: 400 });
    }

    const anthropicResponse = await fetch("https://api.anthropic.com/v1/messages", {
      method: "POST",
      headers: {
        "x-api-key": env.ANTHROPIC_API_KEY,
        "anthropic-version": "2023-06-01",
        "content-type": "application/json",
      },
      body: JSON.stringify({
        model: "claude-3-5-sonnet-latest",
        max_tokens: 300,
        temperature: 0,
        messages: [{ role: "user", content: prompt }],
      }),
    });

    const data = await anthropicResponse.json();
    return Response.json(data);
  },
};

Store the secret in Worker environment variables:

wrangler secret put ANTHROPIC_API_KEY

4. •Call the Worker from Python instead of calling Anthropic directly.

This gives you a production-friendly boundary where your app only talks to Cloudflare, not directly to the model API.

import os
import requests

worker_url = os.environ["WORKER_URL"]

payload = {
    "prompt": (
        "Extract structured follow-up instructions from this note:\n\n"
        "Patient should monitor blood pressure daily, continue metformin, "
        "and schedule cardiology review next week."
    )
}

resp = requests.post(worker_url, json=payload, timeout=30)
resp.raise_for_status()

print(resp.json())

In a real deployment, this is where you attach request IDs, auth tokens, and audit logging headers before the request leaves your app.

5. •Add basic safety checks before sending any healthcare text to the model.

You should not rely on prompt instructions alone. Strip obvious identifiers and reject payloads that are too large or malformed at the edge.

import re

PHI_PATTERNS = [
    r"\b\d{3}-\d{2}-\d{4}\b",   # SSN-like pattern
    r"\b\d{10}\b",              # phone-like pattern without separators
]

def sanitize_text(text: str) -> str:
    cleaned = text.strip()
    for pattern in PHI_PATTERNS:
        cleaned = re.sub(pattern, "[REDACTED]", cleaned)
    return cleaned

clinical_note = """
Patient John Doe SSN 123-45-6789 reports dizziness after taking lisinopril.
Call back at 5551234567.
"""

safe_note = sanitize_text(clinical_note)

print(safe_note)

Use this kind of preprocessing either in your app before calling the Worker or inside the Worker itself if you want all traffic centralized.

Testing the Integration

Run a simple end-to-end test by sending a structured prompt through your Worker and confirming Anthropic returns a usable result.

import os
import requests

worker_url = os.environ["WORKER_URL"]

test_payload = {
    "prompt": (
        "Rewrite this into a concise care-team summary:\n\n"
        "65-year-old with asthma exacerbation improved after nebulizer treatment. "
        "Discharge planned if oxygen saturation remains above 94%."
    )
}

response = requests.post(worker_url, json=test_payload, timeout=30)
response.raise_for_status()

data = response.json()
print(data["content"][0]["text"])

Expected output:

Concise care-team summary:
65-year-old patient with asthma exacerbation improved after nebulizer treatment.
Discharge may proceed if oxygen saturation remains above 94%.

If you get a 400, check payload shape in the Worker. If you get a 401 or 403, check your Cloudflare secret or API token. If you get an Anthropic error back from the Worker, inspect headers and model name first.

Real-World Use Cases

• •

  Clinical note summarization at the edge

  • •Send notes through Cloudflare Workers for validation and redaction.
  • •Use Anthropic to generate short summaries for nurses, coordinators, or claims staff.
• •

  Prior authorization intake assistants

  • •Collect structured patient or provider inputs at the edge.
  • •Have Anthropic extract medical necessity signals into JSON for downstream workflows.
• •

  Patient support triage

  • •Route symptom descriptions through Workers for policy checks.
  • •Use Anthropic to classify urgency and draft next-step guidance for human review.

This pairing works well when you want strict control over ingress plus high-quality language understanding. Keep Cloudflare Workers as the control plane and Anthropic as the reasoning layer, then treat every healthcare payload as sensitive by default.

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.