Parse Asynchronously (Parse Jobs)

Use Parse Jobs v2 to parse documents asynchronously with the Parse v2 API. Submit a document, receive a job_id immediately, then poll for the result instead of holding open a single synchronous request. runs the same parsing as the synchronous Parse API and returns the same Parse v2 response shape. Use it for workflows where you don’t want to wait on a live connection, such as batch pipelines, long-running parses, and documents beyond the synchronous size limits, or when you want to submit work at a lower-cost service tier.

Endpoints

uses one endpoint to submit a job and two to monitor it. All calls use the same host as the synchronous Parse API, https://api.ade.landing.ai.

Action	Method and Path
Create a parse job	`POST /v2/parse/jobs`
Get a parse job	`GET /v2/parse/jobs/{job_id}`
List parse jobs	`GET /v2/parse/jobs`

Workflow Overview

Submit a document to POST /v2/parse/jobs.
Copy the job_id from the response.
Poll GET /v2/parse/jobs/{job_id} until status reaches a terminal state (completed or failed).
When the job completes, read the parsed output from result, or from output_url if you saved the output to a URL.

Create a Parse Job

Submit a document the same way as the synchronous Parse API: a document file upload or a document_url, with an optional model and options. Replace YOUR_API_KEY with your API key.

curl -X POST 'https://api.ade.landing.ai/v2/parse/jobs' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -F 'document=@document.pdf' \
  -F 'model=dpt-3-pro-latest'

from pathlib import Path
from landingai_ade import LandingAIADE

client = LandingAIADE()

job = client.v2.parse_jobs.create(
    document=Path("document.pdf"),
    model="dpt-3-pro-latest",
)
print(job.job_id)

import fs from "fs";
import LandingAIADE from "landingai-ade";

const client = new LandingAIADE();

const job = await client.v2.parseJobs.create({
  document: fs.createReadStream("document.pdf"),
  model: "dpt-3-pro-latest",
});
console.log(job.job_id);

The request returns a 202 response with the job_id, the job’s status, and its creation time:

{
  "job_id": "parse-01k04g2b8xv9q3m5n7r2sd4tfe",
  "status": "pending",
  "created_at": "2026-07-16T18:03:12Z"
}

The status at creation is normally pending; a job that finishes very quickly can already report completed or failed. Treat the job_id as an opaque string; the same id is returned on every poll. accepts the same options as the synchronous endpoint, including page selection, table format, and grounding detail. See Request Options.

Choose a Service Tier

Set the optional service_tier form field to control the job’s turnaround time and credit consumption. Each tier draws from its own rate limit: priority jobs share the synchronous Parse per-minute limit, and standard jobs are measured against your plan’s hourly limit. If you omit service_tier, the job runs on the standard tier. For a comparison of Parse and the two Parse Jobs tiers, see Sync vs Async Processing. For credit consumption by tier, see Credit Consumption.

Tier	Behavior
`standard`	Consumes half the credits of the `priority` tier, with a slower turnaround. Best for cost-sensitive or non-urgent workloads.
`priority`	Consumes credits at the full rate, the same as Parse, with a faster turnaround. Best for time-sensitive jobs.

Set the tier. Include the service_tier field in your create-job request:

curl -X POST 'https://api.ade.landing.ai/v2/parse/jobs' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -F 'document=@document.pdf' \
  -F 'model=dpt-3-pro-latest' \
  -F 'service_tier=priority'

from pathlib import Path
from landingai_ade import LandingAIADE

client = LandingAIADE()

job = client.v2.parse_jobs.create(
    document=Path("document.pdf"),
    model="dpt-3-pro-latest",
    service_tier="priority",
)
print(job.job_id)

import fs from "fs";
import LandingAIADE from "landingai-ade";

const client = new LandingAIADE();

const job = await client.v2.parseJobs.create({
  document: fs.createReadStream("document.pdf"),
  model: "dpt-3-pro-latest",
  service_tier: "priority",
});
console.log(job.job_id);

Monitor a Parse Job

Poll the get-job endpoint with the job_id to check status and retrieve the result when the job finishes.

curl 'https://api.ade.landing.ai/v2/parse/jobs/JOB_ID' \
  -H 'Authorization: Bearer YOUR_API_KEY'

from landingai_ade import LandingAIADE

client = LandingAIADE()

# Fetch the job once. Use client.v2.parse_jobs.wait("JOB_ID") to poll until it finishes.
job = client.v2.parse_jobs.get("JOB_ID")
print(job.status)
if job.status == "completed":
    print(job.result.markdown)

import LandingAIADE, { type V2ParseResponse } from "landingai-ade";

const client = new LandingAIADE();

// Fetch the job once. Use client.v2.parseJobs.wait("JOB_ID") to poll until it finishes.
const job = await client.v2.parseJobs.get("JOB_ID");
console.log(job.status);
if (job.status === "completed") {
  console.log((job.result as V2ParseResponse).markdown);
}

The response reports the job status and, once the job finishes, the result:

Field	Description
`job_id`	The unique identifier for the job. The same id is returned on the create response and every poll.
`status`	The current state of the job. See Job Statuses.
`created_at`	When the job was created, as an ISO-8601 timestamp.
`completed_at`	When the job reached a terminal state, as an ISO-8601 timestamp. Present once the job finishes.
`progress`	An estimate of how close the job is to completion, between `0` and `1`, updated on each poll. Present only while the job is processing, and never reaches `1`. To detect completion, check for a `status` of `completed` instead.
`result`	The parse result, present when `status` is `completed` and you did not save the output to a URL. Contains the full Parse v2 response (`markdown`, `metadata`, and `structure`). See Parse API Response.
`output_url`	The location of the saved output, present only when you supplied `output_save_url`. When set, the full output is delivered to the URL instead of returned in `result`. See Save Parsed Output to a URL.
`metadata`	The job’s `metadata` block, including `billing`. Present on completed jobs that saved their output to a URL, so you can confirm the model version and charge without fetching the file. For inline results, this information is in `result.metadata` instead. See Parse API Response.
`error`	Present when `status` is `failed`. Contains a `code` and a `message`.

Job Statuses

A job moves through these statuses until it reaches a terminal state.

Status	Meaning
`pending`	The job is accepted and queued, but has not started.
`processing`	The job is running.
`completed`	The job finished. Read the result from `result` or `output_url`.
`failed`	The job did not finish. See the `error` field for details.

Get Job Results

When a job reaches completed, the parsed output is returned in one of two ways:

Inline in result. By default, result contains the full Parse v2 response. See Parse API Response for the field-by-field reference.
As a URL in output_url. If you supplied output_save_url when you created the job, saves the output to that URL, output_url contains the location, and result is null. The poll response still reports the job’s metadata. See Save Parsed Output to a URL.

If some pages fail to parse, the completed job still returns every page and the poll request reports a 206 status. See Troubleshoot Parsing.

List Parse Jobs

To retrieve the parse jobs for your organization, call the list endpoint.

curl 'https://api.ade.landing.ai/v2/parse/jobs' \
  -H 'Authorization: Bearer YOUR_API_KEY'

from landingai_ade import LandingAIADE

client = LandingAIADE()

jobs = client.v2.parse_jobs.list()
for job in jobs:
    print(job.job_id, job.status)

import LandingAIADE from "landingai-ade";

const client = new LandingAIADE();

const jobs = await client.v2.parseJobs.list();
for (const job of jobs.jobs) {
  console.log(job.job_id, job.status);
}

The response returns your jobs newest first, as a summary row per job. Use the optional page (0-indexed), page_size, and status query parameters to page through the list or filter by job status.

{
  "jobs": [
    {
      "job_id": "parse-01k04g2b8xv9q3m5n7r2sd4tfe",
      "status": "completed",
      "created_at": "2026-07-16T18:03:12Z",
      "completed_at": "2026-07-16T18:04:37Z",
      "model_version": "dpt-3-pro-20260710",
      "failure_reason": null
    }
  ],
  "page": 0,
  "page_size": 10,
  "has_more": false
}

Field	Description
`jobs`	A summary for each job, containing `job_id`, `status`, `created_at`, `completed_at`, and `model_version` (the model snapshot used). A failed job also reports a `failure_reason`.
`page`	The 0-indexed page number of this list response.
`page_size`	The number of jobs per page.
`has_more`	Whether more jobs are available beyond those returned.

Save Parsed Output to a URL

If you need to manage large outputs or integrate with your existing storage provider, use the output_save_url parameter. When you use this parameter, the output is written to the URL you specify in that parameter, instead of returning it inline in result. The delivered file contains the complete Parse v2 response: markdown, metadata (including billing), and structure. The completed poll response also carries the job’s metadata alongside output_url, so billing information is available without fetching the file.

URL Requirements

If you specify output_save_url, your URL must meet these requirements:

The URL must be a presigned URL that grants time-limited write access to a single object.
These storage provider methods are tested:
Other providers that support presigned URLs may also work, but are not tested.
To maintain security, do not use a publicly accessible URL or expose a storage bucket.
The API cannot access private URLs, such as folders in Google Drive.

Zero Data Retention (ZDR)

In Parse Jobs v1, Zero Data Retention (ZDR) required the document_url and output_save_url parameters. Parse Jobs v2 does not require these parameters; if ZDR is enabled, it applies to all Parse Jobs calls. For the strictest control over sensitive documents, keep them out of the API request and response:

Pass a document as a presigned URL in document_url.
Write the response to a presigned URL specified in output_save_url. See Save Parsed Output to a URL.

Rate Limits

accepts larger files than the synchronous Parse v2 API: a size cap of 1 GiB for PDFs and 50 MiB for images, with the same 6,000-page ceiling per PDF. Usage is metered by pages against the job’s service tier: priority jobs draw from the same per-minute limit as synchronous Parse, and standard jobs are measured against your plan’s hourly limit. A document with more pages than the priority per-minute limit cannot run on that tier; submit it on the standard tier. See Rate Limits.

Get Started

Client Libraries

Parsing

Extraction

General

Security

Administration

Pricing & Credits

Parse Asynchronously (Parse Jobs)

Endpoints

Workflow Overview

Create a Parse Job

Choose a Service Tier

Monitor a Parse Job

Job Statuses

Get Job Results

List Parse Jobs

Save Parsed Output to a URL

URL Requirements

Zero Data Retention (ZDR)

Rate Limits

​Endpoints

​Workflow Overview

​Create a Parse Job

​Choose a Service Tier

​Monitor a Parse Job

​Job Statuses

​Get Job Results

​List Parse Jobs

​Save Parsed Output to a URL

​URL Requirements

​Zero Data Retention (ZDR)

​Rate Limits

Endpoints

Workflow Overview

Create a Parse Job

Choose a Service Tier

Monitor a Parse Job

Job Statuses

Get Job Results

List Parse Jobs

Save Parsed Output to a URL

URL Requirements

Zero Data Retention (ZDR)

Rate Limits