LandingAI Agentic Document Extraction

https://docs.landing.ai/
Admin
LandingAI Agentic Document Extraction provides APIs for parsing, splitting, and extracting...
Tokens:200,913
Snippets:2,287
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Python Library

Source: https://docs.landing.ai/ade/ade-quickstart

Install the landingai-ade package via pip.

```bash
pip install landingai-ade
```

--------------------------------

### Install jq command-line tool

Source: https://docs.landing.ai/ade/ade-quickstart

Install the jq utility required for processing JSON responses from the API.

```bash
brew install jq
```

```bash
winget install jqlang.jq
```

```bash
sudo apt-get install jq
```

--------------------------------

### Install the ADE TypeScript library

Source: https://docs.landing.ai/ade/ade-quickstart

Use npm to install the required landingai-ade package.

```bash
npm install landingai-ade
```

--------------------------------

### Install Zod dependency

Source: https://docs.landing.ai/ade/ade-typescript

Install the Zod library to enable type-safe schema definitions.

```bash
npm install zod
```

--------------------------------

### Page Selection Example

Source: https://docs.landing.ai/llms-full.txt

Example of a valid JSON payload for selecting specific pages.

```json
{"pages": [1, 3]}
```

--------------------------------

### List Parse Jobs API Examples

Source: https://docs.landing.ai/api-reference/tools/ade-list-parse-jobs

Examples for retrieving a list of async parse jobs using cURL, Python, and Node.js.

```cURL
curl -X GET 'https://api.va.landing.ai/v1/ade/parse/jobs' \
  -H 'Authorization: Bearer YOUR_API_KEY'
```

```Python
import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

url = 'https://api.va.landing.ai/v1/ade/parse/jobs'

response = requests.get(url, headers=headers)
print(response.json())
```

```JavaScript
const axios = require('axios');

const url = 'https://api.va.landing.ai/v1/ade/parse/jobs';
```

--------------------------------

### ADE Parse Jobs API Examples

Source: https://docs.landing.ai/api-reference/tools/ade-parse-jobs

Examples for initiating an asynchronous document parsing job using cURL, Python, and Node.js.

```cURL
curl -X POST 'https://api.va.landing.ai/v1/ade/parse/jobs' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -F 'document=@document.pdf' \
  -F 'model=dpt-2-latest'  # Set the model (optional)
```

```python
import requests
import json

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

url = 'https://api.va.landing.ai/v1/ade/parse/jobs'

# Set the model (optional)
data = {
    'model': 'dpt-2-latest'
}

# Upload a document 
document = open('document.pdf', 'rb')
files = {'document': document}

response = requests.post(url, files=files, data=data,
headers=headers)
print(response.json())
```

```javascript
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

const form = new FormData();
form.append('document', fs.createReadStream('document.pdf'));

// Set the model (optional)
form.append('model', 'dpt-2-latest');
```

--------------------------------

### Execute the TypeScript script

Source: https://docs.landing.ai/ade/ade-quickstart

Run the quickstart script using npx and view the output.

```bash
npx tsx quickstart.ts
```

```text
Extracted fields:
{ name: 'Sarah J. Mitchell', number_deposits: 5 }
```

--------------------------------

### Directory Structure Example

Source: https://docs.landing.ai/llms-full.txt

The expected file system structure for saved chunk images.

```text
groundings/
└── document_TIMESTAMP/
    └── page_0/
        └── ChunkType.CHUNK_ID.png
```

--------------------------------

### ADE Parse API Usage Examples

Source: https://docs.landing.ai/api-reference/tools/ade-parse

Examples for interacting with the ADE Parse endpoint using cURL, Python, and Node.js. Ensure you replace 'YOUR_API_KEY' with your actual credentials.

```cURL
curl -X POST 'https://api.va.landing.ai/v1/ade/parse' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -F 'document=@document.pdf' \
  -F 'model=dpt-2-latest'  # Set the model (optional)
```

```python
import requests
import json

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

url = 'https://api.va.landing.ai/v1/ade/parse'

# Set the model (optional)
data = {
    'model': 'dpt-2-latest'
}

# Upload a document 
document = open('document.pdf', 'rb')
files = {'document': document}

response = requests.post(url, files=files, data=data,
headers=headers)
print(response.json())
```

```javascript
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

const form = new FormData();
form.append('document', fs.createReadStream('document.pdf'));

// Set the model (optional)
form.append('model', 'dpt-2-latest');

axios.post('https://api.va.landing.ai/v1/ade/parse', form, {
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    ...form.getHeaders()
  }
})
.then(response => console.log(response.data))
.catch(error => console.error(error));
```

--------------------------------

### ADE Split API Request Examples

Source: https://docs.landing.ai/api-reference/tools/ade-split

Examples for performing document split classification using cURL, Python, and Node.js.

```cURL
curl -X POST 'https://api.va.landing.ai/v1/ade/split' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -F 'markdown=@markdown.md' \
  -F 'split_class=[{"name": "split type name", "description": "description of split type", "identifier": "unique identifier field"}]' \
  -F 'model=split-latest'
```

```Python
import requests
import json

headers = {
    'Authorization': 'Bearer YOUR_API_KEY'
}

url = 'https://api.va.landing.ai/v1/ade/split'

# Prepare split classes
split_class = [
    {
        'name': 'split type name',
        'description': 'description of split type',
        'identifier': 'unique identifier field'
    }
]

# Prepare files and data
files = {'markdown': open('markdown.md', 'rb')}
data = {
    'split_class': json.dumps(split_class),
    'model': 'split-latest'
}

# Run split classification
response = requests.post(url, files=files, data=data,
headers=headers)

# Return the results
print(response.json())
```

```JavaScript
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

const form = new FormData();
form.append('markdown', fs.createReadStream('markdown.md'));

const splitClass = [
  {
    name: 'split type name',
    description: 'description of split type',
    identifier: 'unique identifier field'
  }
];

form.append('split_class', JSON.stringify(splitClass));
form.append('model', 'split-latest');

axios.post('https://api.va.landing.ai/v1/ade/split', form, {
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    ...form.getHeaders()
  }
})
.then(response => console.log(response.data))
.catch(error => console.error(error));
```

--------------------------------

### Authentication Example

Source: https://docs.landing.ai/llms-full.txt

Demonstrates how to authenticate requests to the Landing AI API using a Bearer token.

```APIDOC
## Authentication

### Description
All API requests require authentication using a Bearer token. You can obtain your API key from the settings page of your Landing AI account.

### Security Scheme
- **Type**: HTTP
- **Scheme**: Bearer
- **Bearer Format**: Basic

### Example Request
```javascript
axios.get(url, {
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY'
  }
})
.then(response => console.log(response.data))
.catch(error => console.error(error));
```
```

--------------------------------

### Extracted Fields Output

Source: https://docs.landing.ai/llms-full.txt

Example output showing the extracted data fields.

```text
Extracted fields:
{'name': 'Sarah J. Mitchell', 'number_deposits': 5}
```

--------------------------------

### Initialize Library for EU

Source: https://docs.landing.ai/llms-full.txt

Configure the client library to connect to the EU deployment by setting the environment parameter.

```APIDOC
## Initialize Client (Python)

```python
from landingai_ade import LandingAIADE

client = LandingAIADE(
    environment="eu",
)
```

## Initialize Client (TypeScript)

```typescript
import LandingAIADE from "landingai-ade";

const client = new LandingAIADE({
  environment: "eu"
});
```
```

--------------------------------

### Configure API Key via .env File

Source: https://docs.landing.ai/ade/agentic-api-key

Install dependencies and load the API key from a local .env file.

```bash
pip install python-dotenv
```

```text
VISION_AGENT_API_KEY=your_api_key_here
```

```python
from dotenv import load_dotenv
import os
from landingai_ade import LandingAIADE

# Load environment variables from .env file
load_dotenv()

# Initialize the client (it will automatically use VISION_AGENT_API_KEY from environment)
client = LandingAIADE()
```

--------------------------------

### Initialize Client with Environment Variable

Source: https://docs.landing.ai/ade/agentic-api-key

Explicitly initialize the LandingAIADE client using an environment variable.

```python
import os
from landingai_ade import LandingAIADE

client = LandingAIADE(
    apikey=os.environ.get("VISION_AGENT_API_KEY"),
)
```

--------------------------------

### Initialize ADE Client for EU

Source: https://docs.landing.ai/ade/ade-eu

Configure the client library to route requests to the EU deployment by setting the environment parameter.

```python
from landingai_ade import LandingAIADE

client = LandingAIADE(
    environment="eu",
)
```

```typescript
import LandingAIADE from "landingai-ade";

const client = new LandingAIADE({
  environment: "eu"
});
```

--------------------------------

### GET /v2/extract/jobs/{job_id}

Source: https://docs.landing.ai/api-reference/extract/ade-get-extract-jobs

Get the status of an async Extract job, including its result once the job has completed.

```APIDOC
## GET /v2/extract/jobs/{job_id}

### Description
Get the status of an async Extract job, including its result once the job has completed.

### Method
GET

### Endpoint
https://api.ade.landing.ai/v2/extract/jobs/{job_id}

### Parameters
#### Path Parameters
- **job_id** (string) - Required - The identifier of the job to retrieve, as returned by the create-job request.

### Response
#### Success Response (200)
- **job_id** (string) - The unique identifier for this v2-extract job.
- **status** (string) - The current status of the job (pending, processing, completed, failed).
- **created_at** (string/null) - Timestamp of job creation.
- **completed_at** (string) - Present once the job is terminal.
- **progress** (number) - Job completion as a decimal from 0 to 1.
- **result** (object) - The extraction result returned by the workflow.
```

--------------------------------

### Attestation Block Example

Source: https://docs.landing.ai/dpt3/parse-response

Example of an attestation block containing multiple type labels and transcribed content with placeholders for signatures.

```text
[STAMPED][SIGNED]
Secretary of State use only
IDAHO SECRETARY OF STATE
[HANDWRITTEN_SIGNATURE]
[ILLEGIBLE_SIGNATURE]
```

--------------------------------

### Initialize LandingAI ADE Client for EU

Source: https://docs.landing.ai/ade/ade-python

Set the environment parameter to 'eu' during client instantiation to route requests to the European Union endpoints.

```python
from pathlib import Path
from landingai_ade import LandingAIADE

client = LandingAIADE(
    environment="eu",
)

# ... rest of your code
```

--------------------------------

### ADE Classify JSON Response Example

Source: https://docs.landing.ai/ade/ade-classify-response

Example of a classification response for a multi-page document containing bank statements and pay stubs.

```json
{
  "classification": [
    {
      "class": "bank statement",
      "reason": "Checking account statement for Sarah J. Mitchell from Builder's Bank for the period of September 1 to September 30, 2025.",
      "suggested_class": null,
      "page": 0
    },
    {
      "class": "bank statement",
      "reason": "Continuation of the transaction history and account summary for the September 2025 bank statement.",
      "suggested_class": null,
      "page": 1
    },
    {
      "class": "bank statement",
      "reason": "Checking account statement for Sarah J. Mitchell from Builder's Bank for the period of October 1 to October 31, 2025.",
      "suggested_class": null,
      "page": 2
    },
    {
      "class": "bank statement",
      "reason": "Continuation of the transaction history and account summary for the October 2025 bank statement.",
      "suggested_class": null,
      "page": 3
    },
    {
      "class": "bank statement",
      "reason": "Informational page containing bank policies, fraud protection details, and contact information.",
      "suggested_class": null,
      "page": 4
    },
    {
      "class": "pay stub",
      "reason": "Earnings statement from Acme Corporation for Sarah J. Mitchell for the pay period ending August 31, 2025.",
      "suggested_class": null,
      "page": 5
    },
    {
      "class": "pay stub",
      "reason": "Summary of gross pay, deductions, and net pay for the Acme Corporation earnings statement.",
      "suggested_class": null,
      "page": 6
    },
    {
      "class": "pay stub",
      "reason": "Earnings statement from Acme Corporation for Sarah J. Mitchell for the pay period ending September 15, 2025.",
      "suggested_class": null,
      "page": 7
    },
    {
      "class": "pay stub",
      "reason": "Summary of gross pay, deductions, and net pay for the second Acme Corporation earnings statement.",
      "suggested_class": null,
      "page": 8
    }
  ],
  "metadata": {
    "filename": "SarahMitchell-loan-docs.pdf",
    "org_id": "f6t71a157bx9",
    "page_count": 9,
    "duration_ms": 10865,
    "credit_usage": 4.5,
    "job_id": "c19ab8c311db41b391c50a56a4cdea5c",
    "version": "classify-20260420"
  }
}
```

--------------------------------

### Install ADE skills in Claude Code

Source: https://docs.landing.ai/ade/build-with-ai-agents

Use these commands to add and install the ADE document processing skills plugin within the Claude Code environment.

```bash
/plugin marketplace add landing-ai/ade-document-processing-skills
/plugin install ade-document-processing@ade-document-processing-skills
```

--------------------------------

### ADE Get Parse Jobs API Reference

Source: https://docs.landing.ai/ade/ade-parse-troubleshoot

Documentation for troubleshooting the ADE Get Parse Jobs API, covering status codes and response interpretation.

```APIDOC
## GET /ade-get-parse-job

### Description
Retrieves the status and results of a previously submitted parse job.

### Status Codes
- **200 (Success)**: Job status retrieved successfully. Check the `status` field.
- **206 (Partial Content)**: Job completed but some pages failed. Review `failed_pages` and `failure_reason`.
- **404 (Not Found)**: Job ID not found. Verify the ID and API key.
- **422 (Unprocessable Entity)**: Input validation failed. Verify the job ID format.
- **500 (Internal Server Error)**: Server error. Retry or contact support.

### Job Status Values
- `pending`: Job is queued.
- `processing`: Job is in progress.
- `completed`: Job finished successfully.
- `failed`: Job failed. Check `failure_reason`.
- `cancelled`: Job was cancelled.

### Response Handling
- **Completed Jobs**: Results are in `data` (if < 1MB) or `output_url` (if >= 1MB). If Zero Data Retention is enabled, results are in `output_save_url`.
- **Progress Tracking**: The `progress` field provides a decimal value (0 to 1) representing the percentage of pages processed.
```

--------------------------------

### ADE Get Parse Jobs OpenAPI Specification

Source: https://docs.landing.ai/api-reference/parse/ade-get-parse-jobs

Defines the GET endpoint for retrieving job status, including parameters for the job identifier and the structure of the response object.

```yaml
openapi: 3.1.0
info:
  title: >-
    LandingAI Agentic Document Extraction (ADE) API v2: Parse and Extract
    Documents with DPT-3
  description: >-
    Parse and extract data from documents with DPT-3, a document parsing model
    from LandingAI, using the Agentic Document Extraction (ADE) v2 endpoints.
    Parse converts PDFs and images into structured Markdown and elements with
    per-element grounding (page numbers and coordinates) for RAG, search, and
    extraction pipelines. Extract pulls specific fields from parsed Markdown
    using a JSON schema. Documentation: https://docs.landing.ai
  version: 1.0.0
servers:
  - url: https://api.ade.landing.ai
    description: Production vision tools API
security: []
paths:
  /v2/parse/jobs/{job_id}:
    get:
      tags:
        - Parse
      summary: ADE Get Parse Jobs
      description: >-
        Get the status of an async parse job. Once the job has ``completed``,
        ``result`` carries the parse response (or ``output_url`` when
        ``output_save_url`` was set). Partial success (some pages failed) is
        reported in ``result.metadata.failed_pages``.
      operationId: parse_get_job
      parameters:
        - name: job_id
          in: path
          required: true
          schema:
            type: string
            description: >-
              The identifier of the job to retrieve, as returned by the
              create-job request.
            title: Job Id
          description: >-
            The identifier of the job to retrieve, as returned by the create-job
            request.
      responses:
        '200':
          description: Job status / result
          content:
            application/json:
              schema:
                type: object
                properties:
                  job_id:
                    type: string
                    description: >-
                      The unique identifier for this parse job. Format:
                      ``<service>-<26-character Crockford base32 ULID>``
                      matching ``^(parse|extract)-[0-9a-hjkmnp-tv-z]{26}$``.
                      Opaque, server-minted, and stable for the life of the job
                      — the same id is returned on the sync response, the async
                      202, and every poll. Treat it as opaque; older id formats
                      remain accepted indefinitely and are never re-issued.
                  status:
                    type: string
                    enum:
                      - pending
                      - processing
                      - completed
                      - failed
                    description: >-
                      The job's current status: ``pending``, ``processing``,
                      ``completed``, or ``failed``.
                  created_at:
                    type:
                      - string
                      - 'null'
                    description: ISO-8601 timestamp for when the job was created.
                  completed_at:
                    type: string
                    description: ISO-8601 timestamp; present once the job is terminal.
                  progress:
                    type: number
                    description: >-
                      Job completion as a decimal from 0 (not started) to 1
                      (complete). Present while ``processing``.
                  result:
                    anyOf:
                      - $ref: '#/components/schemas/ParseResponse'
                      - type: 'null'
                    description: >-
                      The parse response, present once the job has ``completed``
                      and ``output_save_url`` was not set. When
                      ``output_save_url`` was set, the result is delivered there
                      and ``output_url`` is returned instead.
                  output_url:
                    type:
                      - string
                      - 'null'
                    description: >-
                      The URL the result was delivered to. Present once the job
                      has ``completed`` and ``output_save_url`` was set, instead
                      of inline ``result``.
                  error:
                    type: object
                    description: >-
                      Present once the job has ``failed`` — the failure code +
                      message.
                    properties:
```

--------------------------------

### Return standard description with custom_prompts

Source: https://docs.landing.ai/ade/ade-parse-custom-prompts

Use this to return a static, predefined string for every figure identified.

```bash
custom_prompts={"figure":"Only return this string as the description: This is an image"}
```

--------------------------------

### Parse and Annotate Documents in Python

Source: https://docs.landing.ai/llms-full.txt

Demonstrates initializing the client, parsing a document, and saving annotated images. Requires the VISION_AGENT_API_KEY environment variable to be set.

```python
pdf.close()
      else:
          # Load image file directly
          img = Image.open(document_path)
          if img.mode != "RGB":
              img = img.convert("RGB")

          # Create and save annotated image
          annotated_img = create_annotated_image(img, parse_response.grounding)
          annotated_path = "page_annotated.png"
          annotated_img.save(annotated_path)
          print(f"Annotated image saved to: {annotated_path}")

      return None

  # Initialize client (uses the API key from the VISION_AGENT_API_KEY environment variable)
  client = LandingAIADE()

  # Replace with your file path
  document_path = Path("/path/to/file/document")

  # Parse the document
  print("Parsing document...")
  parse_response = client.parse(
      document=document_path,
      model="dpt-2-latest"
  )
  print("Parsing complete!")

  # Draw bounding boxes and create annotated images
  draw_bounding_boxes(parse_response, document_path)
```

--------------------------------

### OpenAPI Specification for ADE Get Parse Jobs

Source: https://docs.landing.ai/llms-full.txt

The OpenAPI 3.1.0 definition for the ADE Get Parse Jobs endpoint, including parameters, security requirements, and response schemas.

```yaml
openapi: 3.1.0
info:
  title: >-
    LandingAI Agentic Document Extraction (ADE) API v1: Parse, Extract,
    Classify, Split, Section
  version: 0.1.0
  description: >-
    Convert documents such as PDFs, images, and Office files into structured
    data with LandingAI's Agentic Document Extraction (ADE) v1 endpoints.
    Includes Parse (documents to Markdown and structured chunks with grounding),
    Extract (schema-based field extraction), Classify (page-level
    classification), Split (separate multi-document files), and Section
    (hierarchical table of contents), plus asynchronous jobs for parsing and
    extraction. Documentation: https://docs.landing.ai
servers:
  - url: https://api.va.landing.ai
    description: Production vision tools API
security: []
paths:
  /v1/ade/parse/jobs/{job_id}:
    get:
      tags:
        - Tools
      summary: ADE Get Parse Jobs
      description: |-
        Get the status for an async parse job.

        Returns the job status or an error
           response. For EU users, use this endpoint:


           `https://api.va.eu-west-1.landing.ai/v1/ade/parse/jobs/{job_id}`.
      operationId: tool_ade_get_parse_jobs_v1_ade_parse_jobs__job_id__get
      parameters:
        - name: job_id
          in: path
          required: true
          schema:
            type: string
            title: Job Id
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/JobStatusResponse'
        '206':
          description: There were some pages that failed to be parsed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/JobStatusResponse'
        '404':
          description: Job ID not found
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      security:
        - Basic Auth: []
      x-codeSamples:
        - lang: cURL
          label: cURL
          source: |-
            curl -X GET 'https://api.va.landing.ai/v1/ade/parse/jobs/{job_id}' \
              -H 'Authorization: Bearer YOUR_API_KEY'
        - lang: Python
          label: Python
          source: |-
            import requests

            headers = {
                'Authorization': 'Bearer YOUR_API_KEY'
            }

            url = f'https://api.va.landing.ai/v1/ade/parse/jobs/{job_id}'

            response = requests.get(url, headers=headers)
            print(response.json())
        - lang: JavaScript
          label: Node.js
          source: |-
            const axios = require('axios');

            const url = `https://api.va.landing.ai/v1/ade/parse/jobs/{jobId}`;
```

--------------------------------

### Parse Job Request with Axios

Source: https://docs.landing.ai/api-reference/tools/ade-parse-jobs

Example of how to initiate a parse job using the Axios library in JavaScript.

```javascript
axios.post('https://api.va.landing.ai/v1/ade/parse/jobs', form, {
              headers: {
                'Authorization': 'Bearer YOUR_API_KEY',
                ...form.getHeaders()
              }
            })
            .then(response => console.log(response.data))
            .catch(error => console.error(error));
```

--------------------------------

### OpenAPI Specification for ADE Get Parse Jobs

Source: https://docs.landing.ai/llms-full.txt

The OpenAPI definition for the GET /v2/parse/jobs/{job_id} endpoint, detailing the request parameters and response schema for job status retrieval.

```yaml
openapi: 3.1.0
info:
  title: >-
    LandingAI Agentic Document Extraction (ADE) API v2: Parse and Extract
    Documents with DPT-3
  description: >-
    Parse and extract data from documents with DPT-3, a document parsing model
    from LandingAI, using the Agentic Document Extraction (ADE) v2 endpoints.
    Parse converts PDFs and images into structured Markdown and elements with
    per-element grounding (page numbers and coordinates) for RAG, search, and
    extraction pipelines. Extract pulls specific fields from parsed Markdown
    using a JSON schema. Documentation: https://docs.landing.ai
  version: 1.0.0
servers:
  - url: https://api.ade.landing.ai
    description: Production vision tools API
security: []
paths:
  /v2/parse/jobs/{job_id}:
    get:
      tags:
        - Parse
      summary: ADE Get Parse Jobs
      description: >-
        Get the status of an async parse job. Once the job has ``completed``,
        ``result`` carries the parse response (or ``output_url`` when
        ``output_save_url`` was set). Partial success (some pages failed) is
        reported in ``result.metadata.failed_pages``.
      operationId: parse_get_job
      parameters:
        - name: job_id
          in: path
          required: true
          schema:
            type: string
            description: >-
              The identifier of the job to retrieve, as returned by the
              create-job request.
            title: Job Id
          description: >-
            The identifier of the job to retrieve, as returned by the create-job
            request.
      responses:
        '200':
          description: Job status / result
          content:
            application/json:
              schema:
                type: object
                properties:
                  job_id:
                    type: string
                    description: >-
                      The unique identifier for this parse job. Format:
                      ``<service>-<26-character Crockford base32 ULID>``
                      matching ``^(parse|extract)-[0-9a-hjkmnp-tv-z]{26}$``.
                      Opaque, server-minted, and stable for the life of the job
                      — the same id is returned on the sync response, the async
                      202, and every poll. Treat it as opaque; older id formats
                      remain accepted indefinitely and are never re-issued.
                  status:
                    type: string
                    enum:
                      - pending
                      - processing
                      - completed
                      - failed
                    description: >-
                      The job's current status: ``pending``, ``processing``,
                      ``completed``, or ``failed``.
                  created_at:
                    type:
                      - string
                      - 'null'
                    description: ISO-8601 timestamp for when the job was created.
                  completed_at:
                    type: string
                    description: ISO-8601 timestamp; present once the job is terminal.
                  progress:
                    type: number
                    description: >-
                      Job completion as a decimal from 0 (not started) to 1
                      (complete). Present while ``processing``.
                  result:
                    anyOf:
                      - $ref: '#/components/schemas/ParseResponse'
                      - type: 'null'
                    description: >-
                      The parse response, present once the job has ``completed``
                      and ``output_save_url`` was not set. When
                      ``output_save_url`` was set, the result is delivered there
                      and ``output_url`` is returned instead.
                  output_url:
                    type:
                      - string
                      - 'null'
                    description: >-
                      The URL the result was delivered to. Present once the job
                      has ``completed`` and ``output_save_url`` was set, instead
                      of inline ``result``.
                  error:
                    type: object
                    description: >-
                      Present once the job has ``failed`` — the failure code +
                      message.
                    properties:
                      code:
                        type: string
                        description: Stable error code.
```

--------------------------------

### ADE Get Extract Jobs OpenAPI Specification

Source: https://docs.landing.ai/api-reference/extract/ade-get-extract-jobs

Defines the GET endpoint for retrieving job status and results. The job_id parameter is required to identify the specific extraction task.

```yaml
openapi: 3.1.0
info:
  title: >-
    LandingAI Agentic Document Extraction (ADE) API v2: Parse and Extract
    Documents with DPT-3
  description: >-
    Parse and extract data from documents with DPT-3, a document parsing model
    from LandingAI, using the Agentic Document Extraction (ADE) v2 endpoints.
    Parse converts PDFs and images into structured Markdown and elements with
    per-element grounding (page numbers and coordinates) for RAG, search, and
    extraction pipelines. Extract pulls specific fields from parsed Markdown
    using a JSON schema. Documentation: https://docs.landing.ai
  version: 1.0.0
servers:
  - url: https://api.ade.landing.ai
    description: Production vision tools API
security: []
paths:
  /v2/extract/jobs/{job_id}:
    get:
      tags:
        - Extract
      summary: ADE Get Extract Jobs
      description: >-
        Get the status of an async Extract job, including its result once the
        job has completed.
      operationId: v2-extract_get_job
      parameters:
        - name: job_id
          in: path
          required: true
          schema:
            type: string
            description: >-
              The identifier of the job to retrieve, as returned by the
              create-job request.
            title: Job Id
          description: >-
            The identifier of the job to retrieve, as returned by the create-job
            request.
      responses:
        '200':
          description: Job status / result
          content:
            application/json:
              schema:
                type: object
                properties:
                  job_id:
                    type: string
                    description: >-
                      The unique identifier for this v2-extract job. Format:
                      ``extract-<26-character Crockford base32 ULID>``
                      (``[0-9a-hjkmnp-tv-z]{26}`` tail). Opaque, server-minted,
                      and stable for the life of the job — the same id is
                      returned on the sync response, the async 202, and every
                      poll. Treat it as opaque; older id formats remain accepted
                      indefinitely and are never re-issued.
                  status:
                    type: string
                    enum:
                      - pending
                      - processing
                      - completed
                      - failed
                  created_at:
                    type:
                      - string
                      - 'null'
                  completed_at:
                    type: string
                    description: Present once the job is terminal.
                  progress:
                    type: number
                    minimum: 0
                    maximum: 1
                    description: >-
                      Job completion as a decimal from 0 (not started) to 1
                      (complete). Present while ``processing``.
                  result:
                    anyOf:
                      - description: >-
                          Result returned by V2ExtractOperationWorkflow — the
                          ``/v2/extract``

                          response body (``docs/extract-v2-proposal.md`` →
                          Response).


                          ``extraction`` and ``extraction_metadata`` mirror each
                          other structurally:

                          leaf values in ``extraction`` are replaced by
                          ``ExtractionFieldMetadata``
```

--------------------------------

### Initialize the ADE Client

Source: https://docs.landing.ai/ade/ade-typescript

Initialize the client using the environment variable or by passing the API key explicitly.

```typescript
import LandingAIADE from "landingai-ade";

const client = new LandingAIADE();
```

```typescript
import LandingAIADE from "landingai-ade";

const client = new LandingAIADE({
  apikey: process.env.VISION_AGENT_API_KEY
});
```

--------------------------------

### GET /v1/ade/extract/jobs

Source: https://docs.landing.ai/llms-full.txt

Lists extract jobs with optional filtering.

```APIDOC
## GET /v1/ade/extract/jobs

### Description
Retrieves a list of extract jobs associated with the API key.

### Method
GET

### Endpoint
/v1/ade/extract/jobs

### Parameters
#### Query Parameters
- **page** (integer) - Optional - The page number for pagination.
- **pageSize** (integer) - Optional - The number of items per page.
- **status** (string) - Optional - Filter jobs by status.

### Response
#### Success Response (200)
- **jobs** (array) - A list of extract job objects.
```

--------------------------------

### Create an extraction job

Source: https://docs.landing.ai/api-reference/extract/ade-extract-jobs

Demonstrates how to submit a markdown file and a JSON schema to the extraction jobs endpoint.

```cURL
curl -X POST 'https://api.ade.landing.ai/v2/extract/jobs' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -F 'markdown=@parse-output.md' \
  -F 'schema={"type":"object","properties":{"revenue":{"type":"string","description":"Q1 2024 revenue"}}}'
```

```Python
import json
import requests

url = 'https://api.ade.landing.ai/v2/extract/jobs'
headers = {'Authorization': 'Bearer YOUR_API_KEY'}

files = {'markdown': open('parse-output.md', 'rb')}
data = {
    'schema': json.dumps({
        'type': 'object',
        'properties': {
            'revenue': {'type': 'string', 'description': 'Q1 2024 revenue'}
        }
    })
}

response = requests.post(url, headers=headers, files=files,
data=data)
print(response.json())
```

```JavaScript
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

const form = new FormData();
form.append('markdown', fs.createReadStream('parse-output.md'));
form.append('schema', JSON.stringify({
  type: 'object',
  properties: {
    revenue: { type: 'string', description: 'Q1 2024 revenue' }
  }
}));

axios.post('https://api.ade.landing.ai/v2/extract/jobs', form, {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY', ...form.getHeaders() }
})
  .then(response => console.log(response.data))
  .catch(error => console.error(error));
```

--------------------------------

### GET /v2/extract/jobs

Source: https://docs.landing.ai/api-reference/extract/ade-list-extract-jobs

List your Extract jobs, newest first.

```APIDOC
## GET /v2/extract/jobs

### Description
List your Extract jobs, newest first.

### Method
GET

### Endpoint
https://api.ade.landing.ai/v2/extract/jobs

### Parameters
#### Query Parameters
- **page** (integer) - Optional - Page number (0-indexed). Default: 0.
- **page_size** (integer) - Optional - Number of items per page. Default: 10, Maximum: 100.
- **status** (string) - Optional - Filter by job status.

### Response
#### Success Response (200)
- **jobs** (array) - List of extract jobs.
- **page** (integer) - Current page number.
- **page_size** (integer) - Number of items per page.
- **has_more** (boolean) - Whether there are more pages available.
```

--------------------------------

### List Jobs via Axios

Source: https://docs.landing.ai/api-reference/tools/ade-list-extract-jobs

Example request to retrieve a list of jobs using the Axios library with Bearer token authentication.

```javascript
axios.get(url, {
              headers: {
                'Authorization': 'Bearer YOUR_API_KEY'
              }
            })
            .then(response => console.log(response.data))
            .catch(error => console.error(error));
```

--------------------------------

### Parse Job Response

Source: https://docs.landing.ai/ade/ade-parse-async

Example JSON response containing the job_id.

```json
{'job_id': 'cmfx34ewm0000hyoqkh9dzd8n'}
```

--------------------------------

### Create a Parse Job

Source: https://docs.landing.ai/api-reference/parse/ade-parse-jobs

Examples for initiating a document parsing job using various programming languages.

```cURL
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'
```

```Python
import requests


url = 'https://api.ade.landing.ai/v2/parse/jobs'

headers = {'Authorization': 'Bearer YOUR_API_KEY'}


files = {'document': open('document.pdf', 'rb')}

data = {'model': 'dpt-3-pro-latest'}


response = requests.post(url, headers=headers, files=files,
data=data)

print(response.json())
```

```JavaScript
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

const form = new FormData();
form.append('document', fs.createReadStream('document.pdf'));
form.append('model', 'dpt-3-pro-latest');
```

--------------------------------

### GET /v2/parse/jobs/{job_id}

Source: https://docs.landing.ai/llms-full.txt

Polls the status of an existing parse job.

```APIDOC
## GET /v2/parse/jobs/{job_id}

### Description
Retrieves the status of a specific parse job.

### Method
GET

### Endpoint
/v2/parse/jobs/{job_id}

### Parameters
#### Path Parameters
- **job_id** (string) - Required - The unique identifier of the job.

### Response
#### Success Response (200)
- **status** (string) - The current status of the job (e.g., 'failed').
- **failure_reason** (string) - Description of the cause if the job failed.

#### Success Response (206)
- **status** (string) - The job completed, but some pages failed to parse.

#### Error Responses
- **404 Not Found** - No job with that job_id exists for your account.
```

--------------------------------

### Initialize and Execute Visualization

Source: https://docs.landing.ai/ade/ade-parse-visualize-sample

Orchestrates the document parsing and visualization workflow. Requires the VISION_AGENT_API_KEY environment variable to be set.

```typescript
// Initialize client (uses the API key from the VISION_AGENT_API_KEY environment variable)
  const client = new LandingAIADE();

  async function visualizeChunks() {
    // Replace with your file path
    const documentPath = "/path/to/file/document";

    // Parse the document
    console.log("Parsing document...");
    const parseResponse = await client.parse({
      document: fs.createReadStream(documentPath),
      model: "dpt-2-latest"
    });
    console.log("Parsing complete!");

    // Draw bounding boxes and create annotated images
    await drawBoundingBoxes(parseResponse, documentPath);
  }

  visualizeChunks();
```

--------------------------------

### GET /v1/ade/extract/jobs/{job_id}

Source: https://docs.landing.ai/llms-full.txt

Retrieves the status and data of a specific extract job.

```APIDOC
## GET /v1/ade/extract/jobs/{job_id}

### Description
Retrieves the status and extracted data for a specific job ID. If the job is completed, the response includes the extracted data.

### Method
GET

### Endpoint
/v1/ade/extract/jobs/{job_id}

### Parameters
#### Path Parameters
- **job_id** (string) - Required - The unique identifier of the extract job.

### Response
#### Success Response (200)
- **status** (string) - The current status of the job (e.g., completed, failed).
- **extracted_data** (object) - The data extracted from the document (included if status is completed).
- **failure_reason** (string) - Description of the error if status is failed.

#### Partial Content (206)
- **schema_violation_error** (string) - Details regarding schema non-conformance.
- **warnings** (array) - List of warnings encountered during extraction.

#### Not Found (404)
- **message** (string) - "Job {job_id} not found"
```

--------------------------------

### GET /v2/parse/jobs/{JOB_ID}

Source: https://docs.landing.ai/api-reference/parse/ade-get-parse-jobs

Retrieves the result of a specific parse job by its ID.

```APIDOC
## GET /v2/parse/jobs/{JOB_ID}

### Description
Retrieves the result of a specific parse job by its ID. The response includes the document in markdown format, its hierarchical structure, and associated metadata.

### Method
GET

### Endpoint
https://api.ade.landing.ai/v2/parse/jobs/{JOB_ID}

### Parameters
#### Path Parameters
- **JOB_ID** (string) - Required - The unique identifier of the parse job.

### Response
#### Success Response (200)
- **markdown** (string) - The full document as a single Markdown string.
- **metadata** (object) - Information about the request including model version, page count, and duration.
- **structure** (object) - The document's hierarchical structure including pages and detected elements.

#### Error Response (404)
- **code** (string) - Stable error code.
- **message** (string) - Human-readable error detail.
```

--------------------------------

### Run the grounding script

Source: https://docs.landing.ai/ade/ade-extract-grounding-sample

Execute the grounding script using either Python or TypeScript from the project directory.

```bash
python grounding.py
```

```bash
npx tsx grounding.ts
```
Tokens:
Raw