canonical: https://jentic.com/apis/parse.bot/parse

# Parse Bot Parse API

The Parse API turns a website URL into a callable scraping API: you submit a URL and an optional description of the data you need, and Parse builds endpoints that return that data as JSON. Once a generated API is ready you can execute its endpoints by scraper id and endpoint name, revise it with a plain-language change request, and fetch its OpenAPI document. A public marketplace of pre-built APIs can be searched, subscribed to, or forked privately, and update operations let you preview, merge, or roll back changes to a generated API.

## For AI agents

Build a scraping API from any website URL, run its endpoints by scraper id, revise or fork it, and search Parse's marketplace for a pre-built API before building your own.

## Scope

Does not handle browser automation sessions, proxy rotation settings, or data storage beyond the generated API responses. Use for generating, running, and maintaining scraping APIs built from website URLs only.

## Capabilities

- Generate a scraping API from a website URL by submitting the url and an optional task description to POST /dispatch
- Execute a generated endpoint by scraper_id and endpoint_name with query parameters (GET) or a JSON body (POST)
- Search the Parse marketplace by keyword, category, or country to find a pre-built API for a site
- Subscribe to a marketplace API or fork it privately before customising it
- Revise a completed API with a plain-language revision request and review its revision history
- Check a generated API for available updates, preview an endpoint change, merge it, or roll back the last merge
- Fetch the OpenAPI document of a callable API and an SDK usage example for a task

## Use cases

### Agent builds and calls a scraping API through Jentic

An agent that needs structured data from a site without an official API searches Jentic for the Parse dispatch operation, submits the site URL with a task such as 'return job titles and locations', polls the task until it completes, and then calls the generated endpoint by scraper id and endpoint name. Jentic injects the X-API-Key header at call time, so the agent works with the scraped JSON and never sees the key.

Example prompt: POST /dispatch with url 'https://example.com/careers' and task 'return job title, location, and apply link', poll GET `/dispatch/tasks/{task_id}` until it completes, then call POST `/scraper/{scraper_id}/{endpoint_name}` for the generated endpoint

### Reuse a marketplace API before building

Before generating a new scraper, an agent searches the Parse marketplace with GET `/marketplace/apis` using a keyword and optional country filter, inspects a candidate with GET `/marketplace/apis/{id}`, and subscribes to it. Marketplace browsing needs no API key, so discovery can happen before any credential is involved, and a subscription gives the agent a ready-made endpoint to call.

Example prompt: Call GET `/marketplace/apis` with q 'real estate listings' and country 'US', read the top result's detail with GET `/marketplace/apis/{id}`, then POST `/marketplace/apis/{id}/subscribe`

### Keep a generated API current with site changes

Websites change their layout, so generated APIs drift. Parse exposes GET `/dispatch/tasks/{task_id}/updates` to check for updates from the canonical version, a preview endpoint to test one endpoint's new behaviour with sample params, a merge operation that takes the list of endpoints to update, and a rollback for the last merge if the result is wrong.

Example prompt: Call GET `/dispatch/tasks/{task_id}/updates`, preview the changed endpoint with POST `/dispatch/tasks/{task_id}/preview-update/{endpoint_name}`, then POST `/dispatch/tasks/{task_id}/merge-updates` with that endpoint in the endpoints list

### Refine a scraper with plain-language revisions

When a generated API is missing a field or returns the wrong shape, you send a revision request in plain language to POST `/dispatch/tasks/{task_id}/revise.` If the build asks a clarifying question, POST `/dispatch/{task_id}` carries the user_response, and GET `/dispatch/tasks/{task_id}/revisions` shows the history of changes.

Example prompt: POST `/dispatch/tasks/{task_id}/revise` with revision 'also return the publication date for each article', then list GET `/dispatch/tasks/{task_id}/revisions` to confirm the change

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/dispatch` | Create a new API from a URL |
| GET | `/dispatch/tasks/{task_id}` | Get task detail and build status |
| POST | `/scraper/{scraper_id}/{endpoint_name}` | Execute a generated endpoint |
| GET | `/marketplace/apis` | Search the marketplace |
| POST | `/marketplace/apis/{id}/fork` | Fork a marketplace API privately |
| POST | `/dispatch/tasks/{task_id}/revise` | Revise a completed API |
| GET | `/v1/apis/{scraper_id}/openapi.json` | Get a callable API's OpenAPI document |

## Key resources

- **Dispatch tasks** — Create APIs from URLs, answer input prompts, revise, cancel, and list build tasks and their revisions
- **Scrapers** — Execute a generated API's endpoints by scraper id and endpoint name, and fetch its OpenAPI document
- **Marketplace** — Search pre-built APIs and their endpoints, read API detail, subscribe, or fork privately
- **Updates** — Check, preview, merge, and roll back updates to a generated API

## 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:** 58 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 48 / 100
  - Developer Experience & Jentic Compatibility: 60 / 100
  - AI-Readiness & Agent Experience: 48 / 100
  - Agent Usability: 94 / 100
  - Security: 50 / 100
  - AI Discoverability: 84 / 100
- **View full report:** https://jentic.com/apis/parse.bot/parse/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 Parse API by hand means sending the X-API-Key header on build and execution calls, polling build tasks, and mapping each generated endpoint's parameters yourself. Through Jentic you install once, import Parse from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Parse puts the scraper id in the URL path (`/scraper/{scraper_id}/{endpoint_name}`), so a rule can pin your agent to one generated scraper and the operations you pick. You choose the operations it may call, so actions like cancelling tasks, merging updates, or forking marketplace APIs are not included unless you add them.
- **Credential handling:** Your Parse API key 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 'turn a website into an API' or 'run my scraper endpoint', and Jentic returns the matching Parse operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Firecrawl API** — Crawls and scrapes pages into markdown or structured data per request
- **Apify API** — Runs ready-made and custom scraping actors and stores their datasets
- **Diffbot Extract API** — Extracts articles, products, and other page types with pre-trained models
- **Browserless REST API** — Hosted headless Chrome for screenshots, PDFs, and scripted browsing

## FAQ

### What authentication does the Parse API use?

Per its OpenAPI spec, the Parse API authenticates with an API key sent in the `X-API-Key` header; keys start with `pmx_` and are created in the Parse dashboard under Settings. The marketplace browse operations (searching APIs, searching endpoints, and reading an API's detail) are declared with no security requirement. Through Jentic the key is stored encrypted by your own Jentic One instance and injected at call time, so it never enters the agent's context.

### Can I generate an API for a website that has no official API?

Yes. POST /dispatch takes a required url and an optional task describing the data you want. If a matching API already exists it is returned immediately; otherwise Parse queues a build job, and you follow its progress with GET `/dispatch/tasks/{task_id}.` Once complete, call the generated endpoints through POST `/scraper/{scraper_id}/{endpoint_name}` or the GET form.

### How do I run a generated Parse endpoint through Jentic?

Search Jentic for 'execute a parse scraper endpoint', load the schema for POST `/scraper/{scraper_id}/{endpoint_name}`, and pass the scraper id, endpoint name, and the endpoint's parameters in the JSON body. Jentic attaches the API key and returns the JSON result. To run it on your own infrastructure, install Jentic One from its GitHub repo.

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

The OpenAPI spec does not specify rate limits. Check https://docs.parse.bot for current limits on API builds and endpoint executions.

### Is there a Parse MCP server?

You don't need an MCP server to give your agent the Parse API. Jentic connects it directly from the API Directory: import it, store your API key once, and your agent calls it. Operations are discovered on demand, so no extra tool definitions sit in the agent's context.

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

Yes. For example, write a rule that allows only POST `/scraper/{scraper_id}/{endpoint_name}` and GET `/scraper/{scraper_id}/{endpoint_name}` for one scraper id, so the agent can run that scraper's endpoints and cannot create, revise, fork, or cancel anything. Every call it makes is logged by your Jentic One instance.