canonical: https://jentic.com/apis/easybits.cloud/easybits

# EasyBits API

The EasyBits API runs code inside Firecracker microVM sandboxes, deploys and hosts full apps on managed machines, and gives an agent a working backend: SQL databases, a CDN-backed file store, documents published as sites, and persistent assistants reachable across channels. It also searches, fetches, extracts, and crawls the web, registers custom domains with wildcard certificates, and delivers events through webhooks. Every path lives under one versioned base and returns a consistent error envelope.

## For AI agents

Run code in Firecracker sandboxes, deploy and host apps, query SQL databases, store files on a CDN, and search or crawl the web, all from one backend an agent can call.

## Scope

Does not handle payments, identity providers, or email delivery. Use for sandboxed code execution, app hosting, databases, files, and web access only.

## Capabilities

- Run a command or inline code inside a Firecracker microVM sandbox
- Deploy an app to a managed machine and roll back to an earlier release
- Query, batch-execute, or import into a managed SQL database
- Store files behind a CDN and search them, with soft-delete and restore
- Search, fetch, extract, and crawl web pages for an agent
- Register a custom domain and issue a wildcard certificate
- Run persistent assistants and send them turns across channels

## Use cases

### Execution backend for a coding agent

A coding agent needs somewhere safe to run what it writes. Through Jentic the agent creates a Firecracker microVM sandbox, runs a command synchronously or executes inline code, starts background processes, and reads their logs, so generated code runs in isolation rather than on the host. A sandbox can be snapshotted as a reusable template.

Example prompt: Create a sandbox, run a Python snippet in it, and return the captured output and exit status

### One-call app deployment

An agent ships an app without a manual pipeline. EasyBits launches an app on a managed machine in a single call, publishes and lists releases, restarts in place, and rolls back to an earlier release if a deploy misbehaves. Secrets and logs for the machine are reachable through the same surface.

Example prompt: Launch an app on a managed machine, publish a release, and roll back if the new release fails to start

### Agent-owned data and web layer

An agent needs to store state and gather information. EasyBits gives it a managed SQL database it can query, batch-execute, or import into, a CDN-backed file store with AI file search and soft-delete, and web operations to search, fetch, extract, and crawl pages. The agent keeps its own data and its own view of the web in one backend.

Example prompt: Create a database, import a dataset, then search the web and store the extracted results as files

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v2/sandboxes/{id}/exec` | Run a command synchronously in a sandbox |
| POST | `/api/v2/sandboxes/{id}/run-code` | Run inline code in a sandbox |
| POST | `/api/v2/machines/launch` | Launch an app on a managed machine in one call |
| POST | `/api/v2/machines/{id}/releases` | Publish a release for a machine |
| POST | `/api/v2/databases/{dbId}/query` | Query, batch-execute, or import into a database |
| POST | `/api/v2/web/search` | Search the web |
| POST | `/api/v2/web/extract` | Extract structured data from a page |
| POST | `/api/v2/files` | Register a file and get an upload URL |

## Key resources

- **Sandboxes** — Firecracker microVMs to run commands, inline code, and background processes
- **Machines** — Managed app hosting with launch, releases, rollback, restart, secrets, and logs
- **Databases** — Managed SQL databases to query, batch-execute, or import into
- **Files** — CDN-backed file store with AI search, soft-delete, restore, and duplicate
- **Web** — Search, fetch, extract, and crawl operations
- **Domains** — Custom domains with TXT verification and wildcard certificates

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 60 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 52 / 100
  - Developer Experience & Jentic Compatibility: 63 / 100
  - AI-Readiness & Agent Experience: 48 / 100
  - Agent Usability: 84 / 100
  - Security: 75 / 100
  - AI Discoverability: 61 / 100
- **View full report:** https://jentic.com/apis/easybits.cloud/easybits/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring EasyBits by hand means handling its bearer API key or an OAuth2 flow, learning scopes from READ to ADMIN, and polling async jobs like web extraction yourself. Through Jentic you install once, import EasyBits from the API Directory, store the credential once, and your agent calls it.
- **Permission scoping:** EasyBits puts the machine and sandbox id in the URL path (`/sandboxes/{id}/...` and `/machines/{id}/...`), so a rule can pin your agent to one machine or sandbox and the operations you pick, such as running code and reading logs. Destructive ones like destroying a sandbox or releasing a machine are not included unless you add them.
- **Credential handling:** Your EasyBits key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'run code in a sandbox' or 'deploy my app', and Jentic returns the matching EasyBits operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **E2B** — Runs AI-generated code in isolated cloud sandboxes
- **Railway** — Deploys and hosts apps and databases driven from a git push
- **Render** — Hosts long-running web services, static sites, and managed databases

## FAQ

### What authentication does the EasyBits API use?

The EasyBits API accepts a bearer API key sent as `Authorization: Bearer eb_sk_live_...`, and also supports an OAuth2 authorization-code flow with PKCE for interactive clients, per its OpenAPI spec. Keys carry scopes from READ through WRITE, DELETE, and ADMIN. Through Jentic the credential is stored encrypted by your own Jentic One instance and injected at call time, so it never enters the agent's context.

### Is there an EasyBits MCP server?

You don't need a separate MCP server to give your agent the EasyBits API. Jentic connects it directly from the API Directory: import it, store your key once, and your agent calls its sandbox, database, and deployment operations on demand without loading another server's tool definitions into its context.

### Can I run code in a sandbox with the EasyBits API?

Yes. You create a sandbox, then run a command synchronously or execute inline code inside it, start and manage background processes, and read their logs. Sandboxes are Firecracker microVMs, and you can snapshot one as a reusable template.

### What are the rate limits for the EasyBits API?

The OpenAPI spec does not state specific rate limits. Check the EasyBits documentation at https://www.easybits.cloud/docs for current limits before running high-volume sandbox or crawl workloads.

### Can I limit what my agent is allowed to do with the EasyBits API?

Yes. Write a rule that allows just the operations your agent needs, such as running code and reading logs on a single machine, and leave out destructive ones like destroying a sandbox or releasing a machine. Every call it makes is logged.

### How do I deploy an app with the EasyBits API through Jentic?

Search Jentic for 'deploy my app' and it returns the launch operation with its input schema; your agent publishes a release and can roll back if it fails. To run it on your own infrastructure, install Jentic One from its GitHub repo.