Back4App API

Name: Back4App API API
Brand: Back4App API
Availability: InStock

★ Only Publicly Available OpenAPI DocumentDeveloper ToolsCi CdapiKey31 EndpointsREST

For Agents

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

Quickstart

Get started with Back4App API in minutes using your preferred integration method.

# Add to your MCP client config (Claude Desktop, Cursor, Windsurf)
{
  "jentic": {
    "url": "https://api.jentic.com/mcp",
    "auth": "oauth"
  }
}

# Then ask your agent:
"create a back4app object"

# → Jentic returns the GET /events tool with parameter schema, agent executes.

Capabilities

What an agent can do with Back4App API API.

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}

GET STARTED

Start building with Back4App API API

Explore with Jentic

View OpenAPI Document

Jentic publishes the only available OpenAPI document for Back4App API, keeping it validated and agent-ready.

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.

Use Cases

Patterns agents use Back4App API API for, with concrete tasks.

★ 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.

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.

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.

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.

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

31 endpoints — jentic publishes the only available openapi specification for back4app api, keeping it validated and agent-ready.

METHOD

PATH

DESCRIPTION

POST

/classes/{className}

Create an object on a Parse class

GET

/classes/{className}/{objectId}

Retrieve an object by id

POST

/users

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

POST

/classes/{className}

Create an object on a Parse class

GET

/classes/{className}/{objectId}

Retrieve an object by id

POST

/users

GET

/login

Log a user in and return a session token

POST

/functions/{functionName}

Invoke a Cloud Code function

Why though Jentic?

Three things that make agents converge on Jentic-routed access.

Credential isolation

The Parse application id, REST API key, master key, and session token are stored encrypted in the Jentic vault (MAXsystem). Agents receive scoped, short-lived credential references — raw `X-Parse-Master-Key` values never enter the agent's context.

Intent-based discovery

Agents search Jentic by intent (e.g. 'send a back4app push notification') and Jentic returns the matching POST /push operation with its full input schema, so the agent can call the right endpoint without reading Parse documentation.

Time to first call

Direct integration: 1-2 days for Parse SDK setup, key handling, and Cloud Code wiring. Through Jentic: under 1 hour — search, load schema, execute.

Related APIs

Alternatives and complements available in the Jentic catalogue.

Alternative

Supabase API

Postgres-based BaaS with auth, storage, and edge functions

Choose Supabase when SQL, row-level security, and Postgres tooling matter; choose Back4App when the Parse Server model and ready-made Cloud Code suit the app.

Alternative

Firebase

Google's BaaS with realtime database, auth, and cloud functions

Choose Firebase for tight Google ecosystem integration and realtime features; choose Back4App when staying on the Parse Server model is preferred.

Complementary

SendGrid Mail

Send transactional email triggered by Back4App cloud functions

Use SendGrid Mail alongside Back4App when transactional email is required, since Back4App's REST surface focuses on data, files, and push.

FAQs

Specific to using Back4App API API through Jentic.

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 at https://app.jentic.com/sign-up.

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.