> ## Documentation Index
> Fetch the complete documentation index at: https://e2b.manicule.dev/llms.txt
> Use this file to discover all available pages before exploring further.
> For every page in one file, fetch https://e2b.manicule.dev/llms-full.txt (large).
> To search and read these docs as tools, connect the MCP server at https://e2b.manicule.dev/api/mcp.
> Every agent surface: https://e2b.manicule.dev/.well-known/llms-manifest.json

# Customize the template (/docs/code-interpreting/customize-template)

<!-- agent-signals: reading_time_min: 2 · est_tokens: 1026 · updated: 2026-07-30 -->
Related: [Analyze data with AI](/docs/code-interpreting/analyze-data-with-ai.md), [Code contexts](/docs/code-interpreting/contexts.md), [Create charts & visualizations](/docs/code-interpreting/create-charts-visualizations.md), [Streaming](/docs/code-interpreting/streaming.md), [Supported languages](/docs/code-interpreting/supported-languages.md)

> Extend the Code Interpreter sandbox or build the production template from source

The Code Interpreter SDK runs on the public `code-interpreter-v1` sandbox template. You can customize it in two ways:

1. [Create a custom template](#create-a-custom-template) that extends `code-interpreter-v1` with extra packages or a different runtime — this is the recommended approach for most use cases.
2. [Build the production template](#build-the-production-template) directly from the [`code-interpreter` repository](https://github.com/e2b-dev/code-interpreter) — useful when contributing to the SDK or building the official `code-interpreter-v1` template yourself.

***

## Create a custom template

Use this when you need extra preinstalled packages or a different runtime. Your template builds on top of `code-interpreter-v1`, so everything the Code Interpreter SDK relies on stays in place.

### 1. Install the E2B SDK

<CodeGroup>
```bash title="JavaScript & TypeScript"
npm install e2b dotenv
```

```bash title="Python"
pip install e2b python-dotenv
```
</CodeGroup>

### 2. Create a template file

<CodeGroup>
```typescript title="JavaScript & TypeScript"
// template.ts
import { Template } from 'e2b';

export const template = Template().fromTemplate("code-interpreter-v1");
```

```python title="Python"
# template.py
from e2b import Template

template = Template().from_template("code-interpreter-v1")
```
</CodeGroup>

### 3. Create a build script

<CodeGroup>
```typescript title="JavaScript & TypeScript"
// build.ts
import "dotenv/config";
import { Template, defaultBuildLogger } from 'e2b';
import { template } from './template';

async function main() {
  await Template.build(template, 'code-interpreter-custom', {
    cpuCount: 2,
    memoryMB: 2048,
    onBuildLogs: defaultBuildLogger(),
  });
}

main().catch(console.error);
```

```python title="Python"
# build.py
from dotenv import load_dotenv
from e2b import Template, default_build_logger
from template import template

load_dotenv()

Template.build(
    template,
    alias="code-interpreter-custom",
    cpu_count=2,
    memory_mb=2048,
    on_build_logs=default_build_logger(),
)
```
</CodeGroup>

### 4. Set your environment variables

Create a `.env` file with your API key (loaded by `dotenv` / `load_dotenv()`):

```bash
E2B_API_KEY=e2b_***
```

### 5. Build the template

<CodeGroup>
```bash title="JavaScript & TypeScript"
npx tsx build.ts
```

```bash title="Python"
python build.py
```
</CodeGroup>

### 6. Use the custom template

<CodeGroup>
```js title="JavaScript & TypeScript"
import { Sandbox } from '@e2b/code-interpreter'

const sbx = await Sandbox.create("code-interpreter-custom")
const execution = await sbx.runCode("print('Hello, World!')")
console.log(execution.logs.stdout)
```

```python title="Python"
from e2b_code_interpreter import Sandbox

sbx = Sandbox.create("code-interpreter-custom")
execution = sbx.run_code("print('Hello, World!')")
print(execution.logs.stdout)
```
</CodeGroup>

<Note>See [Install custom packages](/docs/quickstart/install-custom-packages) for preinstalling specific Python and Node.js packages with `pip` / `npm`.</Note>

***

## Build the production template

To build the official `code-interpreter-v1` template from the [`code-interpreter` repository](https://github.com/e2b-dev/code-interpreter), use `build_prod.py`. This is the script CI and releases run, and it's the path to take when you're contributing to the SDK or want to rebuild the production template yourself.

### 1. Clone the repository

The template lives in the `template/` directory — run the remaining steps from there.

```bash
git clone https://github.com/e2b-dev/code-interpreter.git
cd code-interpreter/template
```

### 2. Install the build dependencies

```bash
pip install -r requirements-dev.txt
```

### 3. Provide your credentials

Create a `.env` file with your API key:

```bash
E2B_API_KEY=e2b_***
```

### 4. Build the template

```bash
python build_prod.py
```

To force a clean rebuild that ignores the layer cache, set `SKIP_CACHE=true`:

```bash
SKIP_CACHE=true python build_prod.py
```