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

# Back4App API

Jentic publishes the only available OpenAPI specification for Back4App API, keeping it validated and agent-ready. Back4App is a Backend-as-a-Service platform built on Parse Server that exposes a REST API for object CRUD on dynamic classes, user signup and session management, file storage, push notifications, cloud functions, scheduled jobs, roles, and schema introspection. The spec covers 31 operations across 18 paths under https://parseapi.back4app.com, secured with the Parse-style headers `X-Parse-Application-Id`, `X-Parse-REST-API-Key`, `X-Parse-Session-Token`, and `X-Parse-Master-Key`. Use it to back mobile and web apps with a hosted database, run server-side cloud code, and trigger push notifications without standing up infrastructure.

## For AI agents

Run Parse-style backend operations on Back4App: CRUD across custom classes, user authentication, file uploads, cloud function invocation, push notifications, and schema management.

## Scope

Does not handle Parse Live Queries, dashboard administration, or billing - use for the synchronous Parse REST API surface only.

## Capabilities

- Create, read, update, and delete objects on any user-defined Parse class via `/classes/{className}`
- Sign users up, log in, log out, request password resets, and fetch the current session via /users and /login
- Upload and retrieve files through the `/files/{fileName}` endpoint for app-side asset storage
- Invoke server-side Cloud Code functions and scheduled jobs via `/functions/{functionName}` and `/jobs/{jobName}`
- Send push notifications to user installations through the /push endpoint
- Inspect and manage Parse schemas and roles for fine-grained access control

## Use cases

### Mobile app backend without managing servers

Back a mobile app with the Back4App REST API for user accounts, object storage, and push notifications. The /users, /classes, and /push endpoints together replace a lot of custom backend code, letting a small team ship a feature-complete mobile backend in days rather than weeks.

Example prompt: Sign up a new user with username 'test@example.com' via POST /users, then create a 'Task' object in `/classes/Task` referencing that user.

### Server-side business logic via cloud functions

Run trusted server-side logic by invoking Back4App Cloud Code functions through POST `/functions/{functionName}.` This keeps secrets and validation off the device and makes it easy to enforce business rules consistently across web and mobile clients.

Example prompt: Invoke the cloud function 'sendWelcomeEmail' via POST `/functions/sendWelcomeEmail` with parameters {"userId":"abc123"}.

### Push campaigns to mobile installations

Send push notifications to mobile users by posting to /push with a target query and alert payload. Combined with role and channel filters this gives marketing and product teams a programmable way to reach users without an additional push provider.

Example prompt: POST to /push with a 'where' filter selecting users in channel 'beta-testers' and an alert text 'New build available'.

### Agent-driven backend automation

Let an AI agent perform routine operations against a Back4App backend - creating records, invoking cloud functions, or sending pushes - by going through Jentic. The Parse REST surface is regular and well-typed, which makes it a strong fit for agent tools that need predictable schemas.

Example prompt: Search Jentic for 'create a back4app object', load the schema for POST `/classes/{className}`, and execute it for className='Order' with a sample payload.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/classes/{className}` | Create an object on a Parse class |
| GET | `/classes/{className}/{objectId}` | Retrieve an object by id |
| POST | `/users` | Sign up a new user |
| GET | `/login` | Log a user in and return a session token |
| POST | `/functions/{functionName}` | Invoke a Cloud Code function |
| POST | `/push` | Send a push notification |
| POST | `/files/{fileName}` | Upload a file |
| GET | `/schemas/{className}` | Get the schema for a Parse class |

## Key resources

- **Classes** — CRUD on user-defined Parse classes
- **Users** — Signup, lookup, update, and delete users
- **Sessions** — Login, logout, and current-session retrieval
- **Files** — Upload and download files
- **Functions** — Invoke server-side Cloud Code functions
- **Jobs** — Trigger scheduled background jobs
- **Push** — Send push notifications
- **Roles** — Manage role-based access control
- **Schemas** — Inspect and manage Parse class schemas

## Why Jentic

- **Setup:** Calling the Back4App Parse REST API by hand means sending both the X-Parse-Application-Id and X-Parse-REST-API-Key headers on every request against parseapi.back4app.com and shaping Parse class, user, and function payloads yourself. Through Jentic you install once, import the Back4App API from the API Directory, store the application id and REST API key once, and your agent calls it.
- **Permission scoping:** Back4App puts the class name in the URL path (`/classes/{className}/{objectId}`), so a rule can pin your agent to specific classes it may read or write. You choose the operations it may call, so limit the agent to what it needs, such as creating objects or invoking a Cloud Code function, and destructive calls stay out unless you add them.
- **Credential handling:** Your Back4App application id and REST API key are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'send a Back4App push notification' or 'sign up a new Parse user', and Jentic returns the matching operation with its input schema so the agent calls the right endpoint without reading Parse documentation.

## Related APIs

- **Supabase API** — Postgres-based BaaS with auth, storage, and edge functions
- **Firebase** — Google's BaaS with realtime database, auth, and cloud functions
- **SendGrid Mail** — Send transactional email triggered by Back4App cloud functions

## FAQ

### Why is there no official OpenAPI spec for Back4App API?

Back4App documents its REST API on the website but does not publish a machine-readable OpenAPI specification. Jentic generates and maintains this spec from the Back4App documentation so that AI agents and developers can call the Parse-based REST API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Back4App API use?

Back4App uses Parse-style API key headers: `X-Parse-Application-Id`, `X-Parse-REST-API-Key` for server-to-server reads/writes, `X-Parse-Session-Token` for user-scoped requests, and `X-Parse-Master-Key` for privileged admin operations. Through Jentic these keys are stored in the vault and never enter the agent context directly.

### Can I send push notifications with this API?

Yes. POST /push accepts a `where` query against the Installation class and an `alert` payload, so you can target installations by channel, device type, or custom field. The master key is required for push, which Jentic injects from the vault when the operation is executed.

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

Back4App applies request and concurrency limits per app plan rather than per endpoint, and the spec does not declare a numeric limit. Check your Back4App dashboard for the exact request-per-second and concurrent-connection allowances on your plan.

### How do I create an object in a Parse class through Jentic?

Search Jentic for 'create a back4app object', load the schema for POST `/classes/{className}`, and execute it with `className` set to your target class and a JSON body of fields. Install with `pip install jentic` and use the async search/load/execute pattern.

### Does this API expose Parse Live Queries?

No. The OpenAPI spec covers the synchronous REST API only. Parse Live Queries use a WebSocket protocol that sits outside the REST surface, so they are not callable through this spec or through Jentic.

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

Yes. Because you run Jentic One yourself, your own rules decide which Back4App operations and credentials the agent may use. Back4App puts the class name in the URL path (`/classes/{className}/{objectId}`), so you can pin the agent to specific classes it may read or write and choose the exact operations it may call, such as creating objects or invoking a Cloud Code function via `/functions/{functionName}.` Destructive calls stay out of scope unless you explicitly add them.