canonical: https://jentic.com/apis/bubble/bubble

# Bubble Data API

The Bubble Data API exposes a Bubble application's database as a typed REST surface for creating, reading, updating, replacing, and deleting records on any custom data type. Endpoints are scoped to a type name (for example `/obj/user` or `/obj/order`), with constraint-based filtering, pagination, and bulk creation supported. It is the integration entry point for connecting external services, agents, and back-office tooling to a Bubble no-code application.

## For AI agents

Read, write, update, and delete records in any Bubble app's data types via REST, including bulk creation and constraint-based search.

## Scope

Does not handle Bubble workflow execution, plugin management, or page rendering - use for CRUD on Bubble data types only.

## Capabilities

- List and filter records of any Bubble data type using constraints and cursor pagination
- Create individual records in a typed Bubble database table with createRecord
- Bulk-insert records of the same type in a single request via `/obj/{typename}/bulk`
- Retrieve a single record by its Bubble unique ID for read-then-update workflows
- Patch specific fields on a record without replacing untouched values via updateRecord
- Replace an entire record's fields in one call when the new state is known
- Delete a record by ID for cleanup or right-to-erasure flows

## Use cases

### External Service Sync into a Bubble App

Push records from external systems such as a CRM, billing platform, or form builder into a Bubble application's database so the no-code front end stays in sync. Use createRecord for individual events and bulkCreateRecords for batch imports. The bearer-token model means a backend job can authenticate once and write to any data type exposed in the Bubble Data API settings.

Example prompt: POST a JSON array of products to `/obj/product/bulk` to insert all records in a single request

### Headless Back-Office Operations

Run admin tasks like bulk updates, status changes, and cleanups against a Bubble app without opening the visual editor. listRecords with constraints filters records that need attention, then updateRecord patches fields in place or deleteRecord removes obsolete entries. This pattern keeps operational chores off the no-code canvas and into auditable scripts.

Example prompt: Call listRecords on `/obj/order` with a constraint where status equals 'pending' and updated_date is older than 7 days, then call updateRecord on each ID to set status to 'expired'

### Reporting and Analytics Export

Pull data out of a Bubble app for analytics, BI dashboards, or warehouse loading. The listRecords endpoint accepts cursor-based pagination so a job can iterate through large data types and stream records into a downstream pipeline. Constraints restrict the export to recent records when running incremental syncs.

Example prompt: Call listRecords on `/obj/event` with a created_date constraint and cursor pagination until all rows are exported to the analytics warehouse

### AI Agent CRUD Through Jentic

Allow an AI agent to read and write records in a Bubble app on a user's behalf without storing the API token in the agent runtime. Through Jentic, the agent searches by intent, loads the schema for the relevant operation against `/obj/{typename}`, and executes with the typename and payload supplied by the user's request. The Bubble bearer token stays in your Jentic One instance for the duration of execution.

Example prompt: Use Jentic to search 'create a Bubble record', load the createRecord schema, and execute against `/obj/user` with the new user fields

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/obj/{typename}` | List and search records of a data type with constraints and pagination |
| POST | `/obj/{typename}` | Create a new record on a data type |
| POST | `/obj/{typename}/bulk` | Bulk-create records on a data type |
| GET | `/obj/{typename}/{uid}` | Retrieve a record by its Bubble unique ID |
| PATCH | `/obj/{typename}/{uid}` | Update specific fields on a record |
| PUT | `/obj/{typename}/{uid}` | Replace an entire record's fields |
| DELETE | `/obj/{typename}/{uid}` | Delete a record by ID |

## Key resources

- **Records** — List, search, retrieve, update, replace, and delete records on any data type
- **Bulk Records** — Insert many records of the same data type in a single request

## 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:** 71 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 100 / 100
  - Developer Experience & Jentic Compatibility: 63 / 100
  - AI-Readiness & Agent Experience: 54 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 100 / 100
- **View full report:** https://jentic.com/apis/bubble/bubble/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 the Bubble Data API by hand means holding the app's bearer token, targeting your app's bubbleapps.io host, and writing CRUD calls against each data type yourself. Through Jentic you install once, import the Bubble Data API from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Bubble puts the data type and record id in the URL path (`/obj/{typename}/{uid}`), so a rule can pin your agent to one data type: it can read and create records of that type and nothing else. You choose the operations it may call, so a destructive one like deleting a record is not included unless you add it.
- **Credential handling:** Your Bubble app API token is stored once, encrypted, by your own Jentic One instance and injected as the Authorization header at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a Bubble record', and Jentic returns the matching CRUD operation on `/obj/{typename}` with its schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Buddy Works API** — Triggers CI/CD pipelines that can in turn write deployment metadata into a Bubble database
- **Buffer API** — Schedules social posts whose IDs and metrics can be persisted into a Bubble app
- **Bruzu API** — Generates per-record share images that can be stored on a Bubble record

## FAQ

### What authentication does the Bubble Data API use?

The Bubble Data API uses HTTP bearer authentication. You generate an API token in the Bubble app's Settings > API tab and pass it as Authorization: Bearer <token>. Through Jentic the token is stored encrypted in the vault and injected at execution time, so the agent never sees the raw token in its prompt or logs.

### Can I bulk-create records with the Bubble Data API?

Yes. POST a JSON array of records to `/obj/{typename}/bulk` and Bubble inserts them in a single request, returning the IDs of the created records. This is faster than calling createRecord per row when importing batches and avoids hitting per-second rate limits during onboarding migrations.

### What are the rate limits for the Bubble Data API?

Rate limits depend on the Bubble plan; production apps share a per-app capacity that increases with paid tiers. The spec does not encode specific values - see your app's Settings > Logs for current capacity. When throttled the API returns an error response and clients should back off before retrying.

### How do I list filtered records through Jentic?

Install the SDK with pip install jentic, search for 'list Bubble records', load the listRecords schema, and execute it against `/obj/{typename}` with a constraints array. Each constraint specifies a key, constraint_type (equals, greater than, etc.), and value. Jentic handles pagination cursors automatically when you iterate the result.

### Which data types are exposed by the API?

Only the data types you have explicitly enabled in the Bubble app's API tab are reachable. Each enabled type appears at `/obj/{typename}` where {typename} is the lowercase, hyphenated form of the type's name in the editor. Types that are not exposed return a 404.

### Is the Bubble Data API free?

The Data API is included on Bubble's paid plans (Starter and above). Free apps cannot enable the API. Per-app capacity and concurrency scale with the plan tier - see bubble.io/pricing for current details.

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

Yes. Because your Jentic One instance is self-hosted, your own rules decide which Bubble operations and credentials the agent may use. Since Bubble puts the data type and record ID in the URL path (`/obj/{typename}/{uid}`), you can pin the agent to a single data type so it only reads and creates records of that type and nothing else. You choose the operations it may call, so a destructive one like deleting a record is left out unless you explicitly add it.