Skip to content
Cloudflare Docs

Build an AI code executor

Build an AI-powered code execution system using Sandbox SDK and Claude. Turn natural language questions into Python code, execute it securely, and return results.

Time to complete: 20 minutes

What you'll build

An API that accepts questions like "What's the 100th Fibonacci number?", uses Claude to generate Python code, executes it in an isolated sandbox, and returns the results.

Prerequisites

  1. Sign up for a Cloudflare account ↗.
  2. Install Node.js ↗.

Node.js version manager

Use a Node version manager like Volta ↗ or nvm ↗ to avoid permission issues and change Node.js versions. Wrangler, discussed later in this guide, requires a Node version of 16.17.0 or later.

You'll also need:

1. Create your project

Create a new Sandbox SDK project:

Terminal window
npm create cloudflare@latest -- ai-code-executor --template=cloudflare/sandbox-sdk/examples/minimal
Terminal window
cd ai-code-executor

2. Install dependencies

Install the Anthropic SDK:

Terminal window
npm i @anthropic-ai/sdk

3. Build your code executor

Replace the contents of src/index.ts:

TypeScript
import { getSandbox, type Sandbox } from '@cloudflare/sandbox';
import Anthropic from '@anthropic-ai/sdk';


export { Sandbox } from '@cloudflare/sandbox';


interface Env {
  Sandbox: DurableObjectNamespace<Sandbox>;
  ANTHROPIC_API_KEY: string;
}


export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== 'POST' || new URL(request.url).pathname !== '/execute') {
      return new Response('POST /execute with { "question": "your question" }');
    }


    try {
      const { question } = await request.json();


      if (!question) {
        return Response.json({ error: 'Question is required' }, { status: 400 });
      }


      // Use Claude to generate Python code
      const anthropic = new Anthropic({ apiKey: env.ANTHROPIC_API_KEY });
      const codeGeneration = await anthropic.messages.create({
        model: 'claude-sonnet-4-5',
        max_tokens: 1024,
        messages: [{
          role: 'user',
          content: `Generate Python code to answer: "${question}"


Requirements:
- Use only Python standard library
- Print the result using print()
- Keep code simple and safe


Return ONLY the code, no explanations.`
        }],
      });


      const generatedCode = codeGeneration.content[0]?.type === 'text'
        ? codeGeneration.content[0].text
        : '';


      if (!generatedCode) {
        return Response.json({ error: 'Failed to generate code' }, { status: 500 });
      }


      // Strip markdown code fences if present
      const cleanCode = generatedCode
        .replace(/^```python?\n?/, '')
        .replace(/\n?```\s*$/, '')
        .trim();


      // Execute the code in a sandbox
      const sandbox = getSandbox(env.Sandbox, 'demo-user');
      await sandbox.writeFile('/tmp/code.py', cleanCode);
      const result = await sandbox.exec('python /tmp/code.py');


      return Response.json({
        success: result.success,
        question,
        code: generatedCode,
        output: result.stdout,
        error: result.stderr
      });


    } catch (error: any) {
      return Response.json(
        { error: 'Internal server error', message: error.message },
        { status: 500 }
      );
    }
  },
};

How it works:

  1. Receives a question via POST to /execute
  2. Uses Claude to generate Python code
  3. Writes code to /tmp/code.py in the sandbox
  4. Executes with sandbox.exec('python /tmp/code.py')
  5. Returns both the code and execution results

4. Set up local environment variables

Create a .dev.vars file in your project root for local development:

Terminal window
echo "ANTHROPIC_API_KEY=your_api_key_here" > .dev.vars

Replace your_api_key_here with your actual API key from the Anthropic Console ↗.

5. Test locally

Start the development server:

Terminal window
npm run dev

Test with curl:

Terminal window
curl -X POST http://localhost:8787/execute \
  -H "Content-Type: application/json" \
  -d '{"question": "What is the 10th Fibonacci number?"}'

Response:

{
  "success": true,
  "question": "What is the 10th Fibonacci number?",
  "code": "def fibonacci(n):\n    if n <= 1:\n        return n\n    return fibonacci(n-1) + fibonacci(n-2)\n\nprint(fibonacci(10))",
  "output": "55\n",
  "error": ""
}

6. Deploy

Deploy your Worker:

Terminal window
npx wrangler deploy

Then set your Anthropic API key as a production secret:

Terminal window
npx wrangler secret put ANTHROPIC_API_KEY

Paste your API key from the Anthropic Console ↗ when prompted.

7. Test your deployment

Try different questions:

Terminal window
# Factorial
curl -X POST https://ai-code-executor.YOUR_SUBDOMAIN.workers.dev/execute \
  -H "Content-Type: application/json" \
  -d '{"question": "Calculate the factorial of 5"}'


# Statistics
curl -X POST https://ai-code-executor.YOUR_SUBDOMAIN.workers.dev/execute \
  -H "Content-Type: application/json" \
  -d '{"question": "What is the mean of [10, 20, 30, 40, 50]?"}'


# String manipulation
curl -X POST https://ai-code-executor.YOUR_SUBDOMAIN.workers.dev/execute \
  -H "Content-Type: application/json" \
  -d '{"question": "Reverse the string \"Hello World\""}'

What you built

You created an AI code execution system that:

  • Accepts natural language questions
  • Generates Python code with Claude
  • Executes code securely in isolated sandboxes
  • Returns results with error handling

Next steps