Template names

Template names are unique identifiers used to reference and create sandboxes from your templates. They serve as human-readable names that make it easy to identify and use your templates across your applications.

What is a template name?

A name is a string identifier that you assign to a template when building it. Once a template is built with a name, you can use that name to create sandboxes from the template.

// Build a template with a name
await Template.build(template, 'my-python-env', {
  cpuCount: 2,
  memoryMB: 2048,
})

// Create a sandbox using the name
const sandbox = await Sandbox.create('my-python-env')

Name format

Before a name is used, it’s trimmed of surrounding whitespace and lowercased. The result must match the pattern ^[a-z0-9-_]+$:

• Lowercase letters (a–z), numbers (0–9), dashes (-), and underscores (_)
• Between 1 and 128 characters
• Leading and trailing dashes or underscores are allowed

Uppercase letters are accepted on input and lowercased automatically, so My-Template and my-template refer to the same name. Any other character (spaces inside the name, dots, slashes, and so on) is rejected.

Project-local naming

Template names are scoped to your project. This means:

• Your template named my-app is stored as your-project-slug/my-app
• You can reference it simply as my-app within your project
• Other projects can have their own my-app template without conflict
• Public templates should be referenced using the full namespaced format (project-slug/template-name)

Common use cases

Development and production environments

Use different names for different environments:

// Development template
await Template.build(template, 'myapp-dev', {
  cpuCount: 1,
  memoryMB: 1024,
})

// Production template
await Template.build(template, 'myapp-prod', {
  cpuCount: 4,
  memoryMB: 4096,
})

Multiple template variants

Create different variants of the same template with different configurations:

// Small instance
await Template.build(template, 'myapp-small', {
  cpuCount: 1,
  memoryMB: 512,
})

// Large instance
await Template.build(template, 'myapp-large', {
  cpuCount: 8,
  memoryMB: 8192,
})

Checking name availability

You can check if a name is already in use within your project with the exists method.

import { Template } from 'e2b'

const exists = await Template.exists('my-template')
console.log(`Name ${exists ? 'is taken' : 'is available'}`)

Best practices

1. Use descriptive names: Choose names that clearly indicate the template’s purpose or configuration
2. Use tags for versioning: Instead of baking version numbers into names, use tags for version management (e.g., myapp:v1, myapp:v2)
3. Use consistent naming: Establish a naming convention for your project and stick to it