canonical: https://jentic.com/apis/paraio.org/main

# Paraio Para API

Jentic publishes the only available OpenAPI specification for Para API, keeping it validated and agent-ready. Para is an open-source, general-purpose backend framework/server for the cloud providing CRUD operations for any type of object, full-text search, and authentication. It powers flexible backend infrastructure with type-agnostic object storage and RESTful API endpoints.

## For AI agents

Manage backend objects with CRUD operations across 4 endpoints using flexible object types.

## Scope

Does not handle file uploads, webhooks, or real-time subscriptions - use for RESTful object CRUD and listing only.

## Capabilities

- Create objects of any custom type
- List objects by type with sorting, pagination, and descending order
- Read objects by ID and type
- Update objects with partial modifications
- Delete objects by ID
- Sort and filter object collections

## Use cases

### Type-Agnostic Object Storage

Store and manage objects of any custom type without predefined schemas. POST /{type} creates objects, GET /{type} lists them with sorting and pagination (sort, desc, limit, page parameters), and the type parameter supports any custom schema (users, posts, products, etc).

Example prompt: POST /{type} to create, GET /{type}?sort=created&desc=true&limit=50 to list with sorting

### Object CRUD Operations

Perform complete CRUD operations on backend objects. POST /{type} creates, GET /{type}/{id} reads, PATCH /{type}/{id} updates, and DELETE /{type}/{id} removes objects. Each operation works with any custom type, providing flexible backend management.

Example prompt: POST /{type} to create, GET /{type}/{id} to read, PATCH to update, DELETE to remove

### Paginated Object Listing

Retrieve object collections with pagination, sorting, and filtering. GET /{type} returns items array and totalHits with support for sort (field name), desc (boolean), limit (max results), and page (page number) parameters. Essential for building paginated interfaces.

Example prompt: GET /{type}?sort=timestamp&desc=true&limit=20&page=1 for paginated, sorted results

### Agent-Driven Backend Management via Jentic

An AI agent managing backend infrastructure can create, read, update, and delete objects through Jentic without exposing authentication tokens in agent context. Jentic resolves intents like 'list user objects' to the right Para endpoint with proper type parameters.

Example prompt: Search Jentic for 'list backend objects', load the GET /{type} schema, and execute

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /{type} | Create a new object |
| GET | /{type} | List objects of a type |
| GET | /{type}/{id} | Read an object by ID |
| PATCH | /{type}/{id} | Update an object |

## Key resources

- **ParaObject** — Flexible backend object with custom type and properties

## Why Jentic

- **Setup:** Wiring this Para deployment by hand means resolving your own host, computing AWS Signature V4 or carrying a JWT bearer token, and shaping the generic /{type} object routes yourself. Through Jentic you install once, import Para from the API Directory, store the credential once, and your agent calls it.
- **Permission scoping:** Para puts the object type and id in the URL path (/{type}/{id}), so a rule can pin your agent to one object type: it can create, read, and list those objects. You choose the operations it may call, so writes to other types are not included unless you add them.
- **Credential handling:** Your Para bearer token or signing credential 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 'create an object' or 'list objects of a type', and Jentic returns the matching Para operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Backendless API** — Visual backend development platform with database, APIs, and business logic
- **Back4App API** — A managed backend-as-a-service built on Parse, offering an alternative to Para for hosting your app's data, users, and object storage.

## FAQ

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

Para is open-source but does not publish a complete OpenAPI specification for their REST API. Jentic generates and maintains this spec so that AI agents and developers can call Para API via structured tooling. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Para API use?

Para API uses HTTP bearer token authentication. Through Jentic, tokens are stored in the encrypted vault and injected at execution time so they never enter the agent's prompt context.

### Can I define custom object types?

Yes. The {type} path parameter accepts any custom object type name (users, posts, orders, etc). Para stores objects flexibly without requiring predefined schemas, allowing you to create your own data models.

### How does sorting work?

GET /{type} accepts sort (field name) and desc (boolean for descending order) query parameters. For example, ?sort=created&desc=true sorts by created field in descending order.

### What is the difference between paraio.com and paraio.org?

Both represent the same Para backend framework. paraio.com typically refers to the hosted service while paraio.org is the open-source project site. The API endpoints work identically regardless of deployment.

### Is Para suitable for production use?

Yes. Para is a production-ready, open-source backend framework used by many applications. It can be self-hosted or used as a hosted service, providing flexibility for different deployment requirements.

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

Yes. Because you run Jentic One yourself, your own rules decide which Para operations and credentials the agent may use, and Para puts the object type and id in the URL path (/{type}/{id}), so you can pin the agent to a single object type. You might allow it only to create objects (POST /{type}), read one by id (GET /{type}/{id}), and list a type (GET /{type}), while withholding PATCH /{type}/{id} updates and DELETE calls or access to any other type. Nothing outside the operations you grant is available to the agent.