◈ API / SDK/2026-03-14Advanced

Gemini Code Execution API: to AI-Generated Code Execution

Master the Gemini Code Execution API. Execute Python code generated by AI in a secure sandbox, perform complex calculations, and automate data analysis tasks.

Gemini API¹⁹² Code Execution Python³⁸ Data Analysis³ Automation¹³

✦ Premium Article

Gemini Code Execution API: Complete Guide to AI-Generated Code Execution

Context and Background

The Gemini Code Execution API represents a breakthrough in AI-assisted development. Instead of asking an AI to explain how to solve a problem, you can now let the AI write and execute Python code in a secure Google-managed sandbox environment.

This capability transforms how developers approach computationally intensive tasks. Whether you need complex mathematical calculations, data analysis, statistical modeling, or algorithmic problem-solving, the Code Execution API handles all of this seamlessly. The AI not only generates the code but also executes it and interprets the results—all within a single API call.

This comprehensive guide covers everything from basic setup to advanced production patterns, with practical code examples you can use immediately.

Understanding the Code Execution API

How It Works

The Code Execution API follows this workflow:

Request: You submit a problem or computational task to the API
Code Generation: Gemini AI generates appropriate Python code to solve the problem
Execution: The code runs in Google's isolated, secure sandbox environment
Result Retrieval: Execution results are captured and returned to your application
Interpretation: The AI provides context and explanation based on the execution results

This entire process happens transparently through the API, eliminating the complexity of managing separate code execution infrastructure.

What Makes It Powerful

Unlike traditional API interactions where the AI provides explanations in text, Code Execution enables:

Precision: Mathematical calculations are exact, not approximate or hallucinated
Verification: Results are computed, not synthesized or invented
Iteration: You can refine analyses through multi-turn conversations
Complexity: Handle problems that would be impractical to express as prompts
Transparency: See exactly what code was executed

Supported Environment and Limitations

Code Execution currently operates under these parameters:

Language: Python (JavaScript, Java, and other languages not yet supported)
Execution Environment: Google-managed, isolated sandbox
Time Limit: Maximum 90 seconds per request
Memory: Up to 1GB per execution
Network Access: No external network calls (security by design)
Available Libraries: NumPy, SciPy, Pandas, Matplotlib, and many standard Python libraries

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN

✦Safe implementation of dynamic code execution with Gemini Code Execution API

✦Execution environment control and security best practices

✦Automation of complex computational tasks

Secure payment via Stripe · Cancel anytime

✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

Unlock all articles with Membership →

Getting Started

Installation and Setup

First, install the Google Generative AI SDK:

pip install google-genai

Then set up your API key as an environment variable:

export GEMINI_API_KEY="your-api-key-here"

Your First Code Execution

Here's the simplest possible example to get you started:

from google import genai
import os
 
# Initialize the client
api_key = os.getenv("GEMINI_API_KEY")
client = genai.Client(api_key=api_key)
 
# Request AI to solve a problem using code execution
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[{
        "role": "user",
        "parts": [{
            "text": "Find all prime numbers between 10 and 100. Return the count and their sum."
        }]
    }],
    tools=[{"code_execution": {}}]
)
 
# Process the response
for part in response.content.parts:
    if hasattr(part, 'text'):
        print("AI Response:", part.text)
    elif hasattr(part, 'executable_code'):
        print("Code Generated:", part.executable_code.code)
    elif hasattr(part, 'code_execution_result'):
        print("Execution Output:", part.code_execution_result.output)

Expected Output:

Code Generated:
import math

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True

primes = [n for n in range(10, 101) if is_prime(n)]
print(f"Primes: {primes}")
print(f"Count: {len(primes)}")
print(f"Sum: {sum(primes)}")

Execution Output:
Primes: [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
Count: 21
Sum: 1043

Practical Use Cases

Financial Data Analysis

Analyze stock market or business data with multiple calculations in one request:

from google import genai
import os
 
api_key = os.getenv("GEMINI_API_KEY")
client = genai.Client(api_key=api_key)
 
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[{
        "role": "user",
        "parts": [{
            "text": """
            Analyze this quarterly revenue data:
            - Q1 2024: $1,500,000
            - Q2 2024: $1,800,000
            - Q3 2024: $1,650,000
            - Q4 2024: $2,100,000
 
            Calculate:
            1. Quarter-over-quarter growth rate
            2. Mean and standard deviation
            3. Best and worst performing quarters
            4. Year-over-year total and average
            """
        }]
    }],
    tools=[{"code_execution": {}}]
)
 
# Print results
for part in response.content.parts:
    if hasattr(part, 'code_execution_result'):
        print(part.code_execution_result.output)

Scientific Computing and Statistics

Perform advanced statistical analysis with automatic code generation:

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[{
        "role": "user",
        "parts": [{
            "text": """
            Generate the first 30 Fibonacci numbers and analyze their relationship
            to the golden ratio. Show how the ratio of consecutive pairs converges
            to phi (1.618...). Display all values to 10 decimal places.
            """
        }]
    }],
    tools=[{"code_execution": {}}]
)

Data Visualization and Exploration

Generate and analyze complex datasets with multiple calculation steps:

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=[{
        "role": "user",
        "parts": [{
            "text": """
            Create a normally distributed dataset of 1000 points (mean=100, std=15).
            Perform outlier detection using the IQR method, calculate z-scores,
            and generate descriptive statistics.
            """
        }]
    }],
    tools=[{"code_execution": {}}]
)

Advanced Techniques

Multi-Turn Conversations with Code Execution

Build sophisticated analyses through iterative refinement:

from google import genai
import os
 
api_key = os.getenv("GEMINI_API_KEY")
client = genai.Client(api_key=api_key)
 
# First turn: generate data
messages = [
    {
        "role": "user",
        "parts": [{
            "text": "Generate 100 samples from a normal distribution with mean=50, std=15"
        }]
    }
]
 
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=messages,
    tools=[{"code_execution": {}}]
)
 
print("Turn 1 - Data Generation:")
for part in response.content.parts:
    if hasattr(part, 'text'):
        print(part.text)
 
# Second turn: analyze the data
messages.append({"role": "model", "parts": response.content.parts})
messages.append({
    "role": "user",
    "parts": [{
        "text": "Calculate mean, variance, standard deviation, and skewness for this dataset"
    }]
})
 
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=messages,
    tools=[{"code_execution": {}}]
)
 
print("\nTurn 2 - Statistical Analysis:")
for part in response.content.parts:
    if hasattr(part, 'text'):
        print(part.text)

Output Example:

Turn 1 - Data Generation:
Generated 100 samples with shape (100,)

Turn 2 - Statistical Analysis:
Generated code:
from scipy import stats
import numpy as np

mean = np.mean(data)
variance = np.var(data)
std_dev = np.std(data)
skewness = stats.skew(data)

print(f"Mean: {mean:.4f}")
print(f"Variance: {variance:.4f}")
print(f"Std Dev: {std_dev:.4f}")
print(f"Skewness: {skewness:.4f}")

Output:
Mean: 50.1234
Variance: 223.5678
Std Dev: 14.9520
Skewness: 0.1823

Robust Error Handling and Retries

Production-grade code requires proper error handling:

from google import genai
import os
from google.api_core import exceptions
import time
 
api_key = os.getenv("GEMINI_API_KEY")
client = genai.Client(api_key=api_key)
 
def execute_with_retry(prompt, max_retries=3, backoff_factor=2):
    """Execute code with exponential backoff retry logic"""
    for attempt in range(max_retries):
        try:
            response = client.models.generate_content(
                model="gemini-2.5-flash",
                contents=[{"role": "user", "parts": [{"text": prompt}]}],
                tools=[{"code_execution": {}}]
            )
            return response
 
        except exceptions.DeadlineExceeded as e:
            wait_time = backoff_factor ** attempt
            if attempt < max_retries - 1:
                print(f"Timeout on attempt {attempt + 1}. Retrying in {wait_time}s...")
                time.sleep(wait_time)
            else:
                print(f"Failed after {max_retries} attempts")
                raise
 
        except exceptions.GoogleAPICallError as e:
            print(f"API Error: {e}")
            raise
 
# Usage
try:
    result = execute_with_retry(
        "Calculate the sum of digits for all numbers 1 to 10000"
    )
    print(result)
except Exception as e:
    print(f"Execution failed: {e}")

Response Caching for Cost Optimization

Cache identical requests to reduce API calls and costs:

import hashlib
import json
from datetime import datetime, timedelta
 
class CodeExecutionCache:
    def __init__(self, ttl_minutes=60):
        self.cache = {}
        self.ttl = timedelta(minutes=ttl_minutes)
 
    def _create_key(self, prompt):
        return hashlib.sha256(prompt.encode()).hexdigest()
 
    def get(self, prompt):
        key = self._create_key(prompt)
        if key in self.cache:
            result, timestamp = self.cache[key]
            if datetime.now() - timestamp < self.ttl:
                return result
            del self.cache[key]
        return None
 
    def set(self, prompt, result):
        key = self._create_key(prompt)
        self.cache[key] = (result, datetime.now())
 
cache = CodeExecutionCache(ttl_minutes=30)
 
def cached_execute(prompt):
    # Check cache first
    cached = cache.get(prompt)
    if cached:
        print("Returning cached result")
        return cached
 
    # Execute if not cached
    response = client.models.generate_content(
        model="gemini-2.5-flash",
        contents=prompt,
        tools=[{"code_execution": {}}]
    )
    cache.set(prompt, response)
    return response

Best Practices

1. Input Validation and Sanitization

Always validate and clean user-provided prompts:

def validate_prompt(prompt, max_length=5000):
    """Validate user input before code execution"""
    if not prompt or not isinstance(prompt, str):
        raise ValueError("Prompt must be a non-empty string")
 
    if len(prompt) > max_length:
        raise ValueError(f"Prompt exceeds {max_length} characters")
 
    # Check for suspicious patterns
    dangerous_patterns = ["drop table", "delete from", "exec(", "eval("]
    lower_prompt = prompt.lower()
    for pattern in dangerous_patterns:
        if pattern in lower_prompt:
            raise ValueError(f"Potentially dangerous pattern detected: {pattern}")
 
    return prompt.strip()
 
# Usage
try:
    user_input = request.get("prompt")
    safe_prompt = validate_prompt(user_input)
    response = client.models.generate_content(
        model="gemini-2.5-flash",
        contents=safe_prompt,
        tools=[{"code_execution": {}}]
    )
except ValueError as e:
    return {"error": str(e)}

2. Rate Limiting and Quota Management

Implement rate limiting to stay within API quotas:

import time
from functools import wraps
 
class APIRateLimiter:
    def __init__(self, calls_per_minute=60):
        self.limit = calls_per_minute
        self.calls = []
 
    def __call__(self, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            now = time.time()
            # Keep only calls from the last minute
            self.calls = [t for t in self.calls if now - t < 60]
 
            if len(self.calls) >= self.limit:
                sleep_time = 60 - (now - self.calls[0])
                print(f"Rate limit reached. Waiting {sleep_time:.1f}s")
                time.sleep(sleep_time)
 
            self.calls.append(now)
            return func(*args, **kwargs)
        return wrapper
 
@APIRateLimiter(calls_per_minute=30)
def execute_code(prompt):
    return client.models.generate_content(
        model="gemini-2.5-flash",
        contents=prompt,
        tools=[{"code_execution": {}}]
    )

3. Monitoring and Logging

Track execution metrics for reliability and cost optimization:

import logging
from datetime import datetime
 
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
 
def execute_with_logging(prompt):
    """Execute code with detailed logging"""
    start_time = datetime.now()
 
    try:
        response = client.models.generate_content(
            model="gemini-2.5-flash",
            contents=prompt,
            tools=[{"code_execution": {}}]
        )
 
        elapsed = (datetime.now() - start_time).total_seconds()
        logger.info(f"Execution completed in {elapsed:.2f}s")
 
        # Count tokens used
        input_tokens = response.usage_metadata.prompt_token_count
        output_tokens = response.usage_metadata.candidates_token_count
        logger.info(f"Tokens used - Input: {input_tokens}, Output: {output_tokens}")
 
        return response
 
    except Exception as e:
        logger.error(f"Execution failed: {type(e).__name__}: {str(e)}")
        raise

A Note from an Indie Developer

Final Thoughts

The Gemini Code Execution API transforms how you approach computational problems. Instead of building complex backend systems for calculations, you can now leverage AI to generate, execute, and interpret code automatically.

By following the security best practices and error handling patterns outlined in this guide, you can safely deploy Code Execution in production environments. Whether you're building financial analysis tools, data science platforms, or educational applications, this API provides a powerful foundation for intelligent computation.

Start experimenting with simple problems, then scale to more complex use cases as you become familiar with the API's capabilities and patterns. The combination of AI code generation and verified execution opens up new possibilities for building intelligent, responsive applications.

Thank You for Reading

Gemini Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.