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

# Backendless API

Backendless is a Backend-as-a-Service platform that exposes a REST API covering user management, schemaless data persistence, file storage, messaging, push notifications, atomic counters, caching, and logging. The 29 documented endpoints group around /users, `/data/{tableName}`, /files, /messaging, /counters, /cache, and /logging, so a frontend or mobile client can hit one base URL for most backend needs. Custom business logic is invocable through `/services/{serviceName}/{method}.` Authentication is performed once at `/users/login` and then carried via a user-token header.

## For AI agents

Register users, query and mutate schemaless tables, upload files, publish messages, and increment counters on the Backendless BaaS platform.

## Scope

Does not handle payment processing, dedicated CRM, or hosted website builders - use for app backend persistence, auth, file storage, and messaging only.

## Capabilities

- Authenticate users via register, login, password restore, and logout flows
- Query, insert, update, and delete schemaless objects per table with bulk variants
- Upload, list, and delete files at arbitrary storage paths
- Publish messages to named channels and send push notifications and transactional email
- Increment atomic counters and read their current value for lightweight analytics
- Read, write, and invalidate values in a managed key-value cache
- Invoke custom server-side business logic through named services and methods

## Use cases

### Mobile App Backend

Use Backendless as the entire backend for an iOS or Android app: user signup and login via `/users/register` and `/users/login`, profile data in `/data/Users`, attachments in /files, and push notifications via `/messaging/push.` The schemaless data API means new fields can be added by clients without server migrations, accelerating feature delivery for small teams.

Example prompt: Register a user via POST `/users/register`, then upload a profile photo to `/files/profiles/{userId}.jpg` using the user-token from the login response.

### Realtime Messaging and Notifications

Backendless supports server-to-client push notifications, channel-based messaging, and transactional email from a single API. POST `/messaging/{channel}` broadcasts a JSON message to subscribers, `/messaging/push` sends OS-level pushes, and `/messaging/email` sends a transactional email. This works as a lightweight alternative to wiring separate Firebase, Pusher, and SendGrid stacks.

Example prompt: Publish a JSON message to `/messaging/orders` announcing a new order, then call `/messaging/push` to alert the assigned delivery rider's device.

### Counter and Cache for Lightweight Analytics

The atomic counter API at `/counters/{counterName}` and the cache API at `/cache/{key}` let agents and client apps maintain counts (page views, votes, leaderboard scores) and ephemeral key-value state without provisioning a Redis instance. PUT increments a counter; GET returns the current value. Cache entries support standard PUT/GET/DELETE.

Example prompt: Increment counter 'homepage_views' via PUT `/counters/homepage_views`, then GET the counter to confirm the new value.

### AI Agent Integration via Jentic

An agent built on Jentic can use Backendless as its persistence layer: store conversation context in `/data/Conversations`, cache scratchpad state in /cache, and notify users by pushing through `/messaging/push.` Jentic isolates the user-token and REST API key in your Jentic One instance so the agent never holds raw credentials.

Example prompt: Search Jentic for 'create a backendless data object', load the schema for POST `/data/{tableName}`, and execute it with table 'AgentRuns' and a JSON payload of the run summary.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/users/register` | Register a new user |
| POST | `/users/login` | Log in a user and receive a session token |
| GET | `/data/{tableName}` | Find objects in a table |
| POST | `/data/{tableName}` | Create a data object |
| POST | `/files/{filePath}` | Upload a file |
| POST | `/messaging/push` | Send a push notification |
| POST | `/messaging/email` | Send a transactional email |
| PUT | `/counters/{counterName}` | Increment or decrement an atomic counter |

## Key resources

- **Users** — Register, login, logout, restore password, and CRUD on user records
- **Data** — Schemaless table objects with single and bulk CRUD plus a count endpoint
- **Files** — Upload, list, and delete files at arbitrary storage paths
- **Messaging** — Channel publish, push notifications, and transactional email
- **Counters** — Atomic counter get and increment/decrement
- **Cache** — Key-value cache get, put, and delete
- **Services** — Invoke custom server-side business logic by service and method name

## Why Jentic

- **Setup:** Wiring Backendless by hand means embedding the application id and REST API key into the base URL, running the `/users/login` call, and threading the returned user-token header through every subsequent request across /users, /data, /files, and /messaging. Through Jentic you install once, import the Backendless API from the API Directory, store the REST API key and user-token once, and your agent calls it.
- **Permission scoping:** Backendless puts the target in the URL path for many operations (`/data/{tableName}`, `/files/{filePath}`, `/counters/{counterName}`), so a rule can pin your agent to one table or path: it can read and write that table and nothing else. You choose the operations it may call, so destructive ones like DELETE on `/data/{tableName}` are not included unless you add them.
- **Credential handling:** Your Backendless REST API key and user-token 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 'register a user' or 'send a push notification', and Jentic returns the matching Backendless operation with its input schema so the agent calls the right endpoint without browsing /users, /data, /files, and /messaging separately.

## Related APIs

- **Bagisto** — E-commerce platform that could use Backendless for ancillary mobile features
- **Expertease apis** — Chatbot backend that can persist conversation context in Backendless tables
- **balldontlie** — A read-only sports data API; not a BaaS, but illustrates simple REST data access

## FAQ

### What authentication does the Backendless API use?

Per-request authentication is via the user-token header (apiKey scheme). The application-id and REST API key are embedded in the base URL https://api.backendless.com/{application-id}/{REST-api-key}. The user-token is obtained from POST `/users/login.` Through Jentic, both the REST key and user-token are stored encrypted and never reach the agent's context.

### Can I create many records at once with the Backendless API?

Yes. Bulk endpoints exist: POST `/data/bulk/{tableName}` to create, PUT `/data/bulk/{tableName}` to update, and DELETE `/data/bulk/{tableName}` to delete in batches. Use the single-object endpoints under `/data/{tableName}` for one-at-a-time operations.

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

Rate limits are not declared in the OpenAPI spec. Backendless enforces limits per pricing plan; consult https://backendless.com/docs/rest/ and your plan dashboard before high-volume bulk operations.

### How do I send a push notification through Jentic?

Search Jentic for 'send a backendless push notification', load the schema for POST `/messaging/push`, then execute with the device segment and notification payload. Jentic injects the REST API key and user-token at execution time so the agent never sees them.

### Does Backendless support file storage?

Yes. POST `/files/{filePath}` uploads a file at the chosen path, GET `/files/{directoryPath}` lists files in a directory, and DELETE `/files/{filePath}` removes a file. There is no separate object-storage service to provision.

### Can I run custom server-side logic through this API?

Yes. Backendless supports custom business logic services. Invoke them via POST `/services/{serviceName}/{method}` with the parameters expected by your custom service. This is how you extend the platform beyond the built-in CRUD.

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

Yes. Because you run your own self-hosted Jentic One instance, your rules decide which Backendless operations and credentials the agent may use. Since Backendless puts the target in the URL path, you can pin the agent to a single table, file path, or counter, such as read and write on `/data/{tableName}` while excluding it from every other table. You choose the operations it can call, so destructive ones like DELETE on `/data/{tableName}` are never available unless you explicitly add them.