Parse Bot Parse API
58
AI ReadinessFoundational (C+)58/100
Official vendor OpenAPI document · agent-readyData EnrichmentData TransformationapiKey22 EndpointsREST
For 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.
Use for: I need to turn a product listing page into an API that returns prices as JSON, Search the Parse marketplace for an existing API for a news site, Run the search endpoint of my generated scraper with a query parameter, Check whether my generated API has updates waiting to be merged
Not supported: 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.
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.
Install Jentic One Beta
Connect the Parse API to your agent
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Parse API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
1
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fparse.bot%2Fparse" | sh2
Step 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fparse.bot%2Fparse" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
Capabilities
What an agent can do with Parse API.
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
Patterns agents use Parse API for, with concrete tasks.
★ 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.
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.
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.
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.
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
22 endpoints — 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.
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
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
Jentic AI Readiness Score
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.
P
Parse API
- Foundational (C+)58/100
48
Foundational Compliance60
Developer Experience & Jentic Compatibility48
AI-Readiness & Agent Experience94
Agent Usability50
Security84
AI DiscoverabilityPowered by JenticScoring Framework 1.0.0 | Scoring Engine 0.4.2
Show dimension breakdown
48
Foundational Compliance
Base layer of spec validity and structural soundness.
Grade: D+Signals: 4
81%
Lint Results
Aggregated quality score from linter diagnostics, weighted by severity.
100%
Resolution Completeness
Percentage of `$ref` references that resolve successfully.
0%
Specification Validity
Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).
10%
Structural Integrity
Structural correctness score based on schema issues using logarithmic dampening.
60
Developer Experience & Jentic Compatibility
Clarity, completeness, and ingestion readiness for developers and tooling.
Grade: C+Signals: 4
3%
Example Density
How richly the API is illustrated with examples.
100%
Example Validity
Percentage of examples that conform to their schemas.
36%
Response Coverage
Percentage of operations with complete response definitions (success, client error, server error).
100%
Tooling Readiness
Health of API ingestion, bundling, and resolution within Jentic pipelines.
48
AI-Readiness & Agent Experience
Semantic breadth, depth, and agent comprehension for AI systems.
Grade: D+Signals: 4
41%
Description Coverage
Coverage of descriptions across API elements.
0%
Error Standardization
Coverage of RFC 9457 Problem Details for error responses.
100%
OperationId Quality
Coverage, uniqueness, and casing consistency of operationIds for AI inference.
50%
Summary Coverage
Coverage of summaries across operations/tags/info.
94
Agent Usability
Functional utility, complexity comfort, and AI orchestration readiness.
Grade: A+Signals: 1
94%
Complexity Comfort
Agent comfort level based on API operational and structural complexity.
50
Security
Trust, risk posture, and security compliance.
Grade: C-Signals: 1
50%
Authentication Strength
Average quality of security schemes based on authentication method strength (weakest link for OAuth2).
84
AI Discoverability
Findability, semantic richness, and reasoning readiness.
Grade: ASignals: 1
84%
Descriptive Richness
Clarity and depth of descriptions across API elements.
Score it yourself
Every API in the directory is allowlisted, so you can re-score it with no key required.
npx @jentic/api-scorecard-cli score <openapi-url>Why Jentic?
What agents get from Jentic-routed access to this vendor.
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 isolation
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.
Intent-based discovery
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
Alternatives and complements available in the Jentic catalogue.
FAQs
Specific to using Parse API through Jentic.
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.
GET STARTED