---
type: "post"
id: "introducing-e2b-workload-identity-90f2df"
slug: "introducing-e2b-workload-identity-90f2df"
title: "Introducing E2B Workload Identity"
description: "E2B says Workload Identity is generally available on E2B Cloud and supported for BYOC deployments with enablement from support."
retrieval_nugget: "E2B says Workload Identity is generally available on E2B Cloud and supported for BYOC deployments with enablement from support. It injects a signed JWT into configured outbound HTTPS requests, letting backend services verify a sandbox’s project and execution identity and apply their own permissions instead of relying on shared or per-sandbox long-lived credentials."
published_at: "2026-11-04"
updated_at: "2026-11-04"
record_date: "2026-11-04"
date_kind: "published_at"
topics: ["agent-security","sandbox"]
entities: ["E2B","E2B Workload Identity","AWS Security Token Service","Amazon S3","OpenID Connect"]
related_patterns: ["agent-security-moves-to-runtime-boundaries"]
novelty_label: "new_fact"
what_changed: "E2B adds Workload Identity, issuing signed, audience-bound JWTs that identify the project, sandbox, and execution on outbound requests, without exposing tokens inside the sandbox."
prior_refs: []
source_url: "https://e2b.dev/resources/introducing-e2b-workload-identity"
source_urls: ["https://e2b.dev/resources/introducing-e2b-workload-identity"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:introducing-e2b-workload-identity-90f2df"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/introducing-e2b-workload-identity-90f2df/","markdown":"https://newruntime.com/posts/introducing-e2b-workload-identity-90f2df.md","json":"https://newruntime.com/posts/introducing-e2b-workload-identity-90f2df.json"}
markdown_url: "https://newruntime.com/posts/introducing-e2b-workload-identity-90f2df.md"
---

# Introducing E2B Workload Identity

## Retrieval answer

E2B says Workload Identity is generally available on E2B Cloud and supported for BYOC deployments with enablement from support. It injects a signed JWT into configured outbound HTTPS requests, letting backend services verify a sandbox’s project and execution identity and apply their own permissions instead of relying on shared or per-sandbox long-lived credentials.

## Summary
E2B says Workload Identity is generally available on E2B Cloud and supported for BYOC deployments with enablement from support. It injects a signed JWT into configured outbound HTTPS requests, letting backend services verify a sandbox’s project and execution identity and apply their own permissions instead of relying on shared or per-sandbox long-lived credentials.

## What happened
E2B’s November 3, 2026 product post introduces Workload Identity for sandboxes. The problem it addresses is how a backend can identify a sandbox making a request: a shared API key may authenticate a caller without identifying which sandbox sent it, while separate credentials for every sandbox require distribution, rotation, and tracking. E2B says it supplies a signed JSON Web Token (JWT) identifying the project, sandbox, and execution behind a request.

To configure it, a developer defines a named workload token and its audience—the intended receiving service—and references that token in a network rule. When a matching HTTPS request leaves the sandbox, E2B adds a signed token to a configured request header. The code inside the sandbox makes a normal HTTPS request and need not construct the authorization header itself. E2B says issuance occurs outside the sandbox, so the token is not placed in its environment or filesystem. A token has an expiration and intended audience; E2B may reuse a cached token for the same sandbox execution and audience while it remains valid.

The receiving service is responsible for verification and authorization. For E2B Cloud, E2B publishes an OIDC discovery document identifying `https://id.e2b.dev` as issuer and pointing to its JSON Web Key Set. The service should verify the signature, expected issuer and audience, expiration and not-before times, and that the subject belongs to the expected project and sandbox execution. The post describes connecting a sandbox identity to an application permission, such as checking that a sandbox is assigned to a document-processing task before returning that task’s document. E2B provides identity; the application decides which resources and operations that identity may access.

E2B also documents an AWS example. A backend can pass the JWT to AWS Security Token Service (STS) using `AssumeRoleWithWebIdentity`, then use the resulting temporary credentials to read an S3 object. The example sets the token audience to `sts.amazonaws.com`, registers E2B as an OIDC provider, and uses an IAM role trust policy that checks audience and project subject. Its AWS credentials are set to expire after 15 minutes. E2B warns that provider registration alone does not restrict access to a project, and that job-specific documents require an additional identity-to-permission check. Workload Identity is generally available on E2B Cloud; BYOC deployments use their own issuer and keys and require support to enable the feature. No price is stated.

## What the archive adds
This is a new fact on a known E2B deployment story. [Introducing E2B Embed](https://newruntime.com/posts/introducing-e2b-embed-analysis-5c9436/) covered customer-controlled sandbox deployment; Workload Identity addresses a different boundary, how deployed sandboxes identify themselves to services. Earlier Field Notes also covered [E2B’s internal sandbox development workflow](https://newruntime.com/posts/how-e2b-uses-its-own-sandboxes-to-develop-6c3c0c/), but this announcement concerns an external integration capability, not that workflow.

## Trend signal
This supports [agent security moves to runtime boundaries](https://newruntime.com/patterns/agent-security-moves-to-runtime-boundaries/): E2B places token issuance outside the sandbox and gives services a verifiable workload identity to check. It does not establish that runtime identity alone provides safe authorization; the post explicitly leaves resource permissions to the application and IAM policy.

## Why it matters
A sandbox that can reach an internal service is useful only if the service can make a meaningful access decision. E2B’s mechanism gives backend teams claims to verify about the calling project and execution, and lets them bind those claims to application-level permissions. For AWS-backed workflows, the documented federation path can avoid storing long-lived AWS access keys in a sandbox and use temporary credentials instead.

The boundary is important: signed identity is not the same as authorization. Teams still need narrowly scoped role trust policies, audience and subject checks, and a mapping from sandbox identity to the particular task or data it may access. The source’s S3 example permits any identity accepted by its trust policy to read the same object; it cautions that individual job permissions need another check. This feature therefore offers a useful credential and identity primitive, not an automatic policy system.

## Limits and uncertainty
The announcement documents the mechanism and AWS federation example but provides no pricing, performance measurements, token lifetime beyond the example’s AWS credentials, adoption data, or comparison with other identity approaches. It does not establish that a valid token makes a request safe: services must validate claims and implement authorization themselves. BYOC support requires enablement, and the post does not specify rollout timing or availability terms beyond saying it is supported. The S3 sample also does not implement per-job authorization unless the backend adds the described identity check.

## Skill to build now
For a sandbox-to-service path, write down the intended audience, issuer, subject constraints, and the exact resource permission before adding a token. Implement verification in the receiving service, then bind the verified sandbox execution to an assigned task rather than authorizing every valid project identity alike. If federating to AWS, review the role trust policy for audience and project-subject restrictions and scope its resource policy to the smallest required object or action.

## Reader takeaway
E2B Workload Identity gives outbound sandbox requests a signed, verifiable identity and can bridge that identity to temporary AWS credentials. It does not decide what the sandbox may do. The backend or cloud role must verify the claims and enforce task- and resource-level permissions.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Agent Security](https://newruntime.com/topics/agent-security.md): Explore the agent-security topic hub.
- topic hub: [Sandbox](https://newruntime.com/topics/sandbox.md): Explore the sandbox topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)