Prepare your Parse or Extract async task integration based on the finalized REST field protocol, and understand the production entry release boundaries.
The REST API is designed for backend services, cross-language systems, and workflow orchestration. The public field protocol is finalized, defining Bearer API Key authentication,
All requests use JSON with
The finalized protocol requires choosing between
When the result is not yet ready, the API may return HTTP
config_id, biz_id, business paths, and async result query semantics, so you can prepare your integration code.
Integration Prerequisites
- You have ParseX console access and enter the target Workspace through the officially authorized entry; if you do not have access, contact the service provider or administrator first — do not generate or guess console URLs.
- You have validated and saved a Parse or Extract configuration with real samples and obtained its
config_id. - You have prepared compliant input file URLs; when Extract reuses parse results, you also need a valid
parsed_file_biz_id. - You have planned for the server side to securely store the
biz_idreturned by REST and perform async result queries once the production Base URL and official authentication method are released.
Finalized Business Paths
| Method | Business Path | Purpose |
|---|---|---|
POST | /parse/submit | Submit a Parse task |
POST | /parse/result | Query Parse status, results, or shards |
POST | /extract/submit | Submit an Extract task |
POST | /extract/result | Query Extract status and results |
snake_case fields and carry the following headers:
Authentication
API Keys should only be stored on the server side or in a key management system. Do not write them into browser code, repositories, task parameters, or logs.
Use Saved Configurations
The finalized protocol requires choosing between config_id and inline capability parameters. Once the production entry is released, we recommend referencing validated configurations to avoid having different services maintain parsing or extraction rules separately.
- Parse
- Extract
A configuration-based call must at least express the following semantics:
Call Flow
-
Wait for the official Base URL release
The production Base URL has not been publicly confirmed. Before the official production endpoint is released, do not treat the
{BASE_URL}placeholder as a real address, and do not substitute it with staging or internal addresses. -
Submit a task
Once the official endpoint is available, call the corresponding
submitendpoint, passing the file source, a capability-matchingconfig_id, and the per-run parameters allowed by the protocol. Per-run parameters should not change the processing definition of the saved configuration. -
Save request and task identifiers
Save
request_idanddata.biz_idfrom the response.request_ididentifies this API request, andbiz_idis used to query the async business task later. -
Query task status
Call the corresponding
resultendpoint with the originalbiz_id. Keep polling whiledata.statusisprocessing; stop when it issuccessorfailed. -
Handle results or errors
On success, read the official Parse or Extract result; on failure, save the error code,
request_id,biz_id, andconfig_id, and troubleshoot with the public error codes.
Status and Tracking
| Identifier or status | Meaning | Client handling |
|---|---|---|
request_id | Locator identifier for an API request | Record it for every submission and query; provide it together with the error code when troubleshooting |
biz_id | Identifier of an async business task | Persist after submission and use it with the corresponding result endpoint |
processing | The task is still processing | Continue querying the original task with a backoff strategy; avoid resubmitting due to waiting |
success | The official result is readable | Validate the result structure and associate it with config_id, input, and business records |
failed | The task failed | Decide whether to fix the input, stop, or retry based on the error code |
409 and ResultNotReady. The client should keep querying the original biz_id instead of creating a new task that cannot be correlated.
Retries and Duplicate Submissions
- The client should save its own business correlation key, submission time, and the
request_idandbiz_idreceived in the response. - If a submit request times out without a response, the public protocol cannot automatically confirm whether the task was created; fall back to a manual or business-side reconciliation process and accept that duplicate submissions cannot be automatically ruled out.
- Use a capped backoff strategy for result queries; do not poll at high frequency.
- Only automatically retry errors explicitly marked as retryable; parameter, format, or configuration conflicts should be fixed first.
Related References
- API Overview: Learn about authentication, Base URL placeholder conventions, public business paths, and the async call flow.
- Error Codes: Decide how to handle errors based on HTTP status and error codes.
- Tasks and Usage: Learn about public REST task statuses and the console's "Task Records" and usage pages.