> ## Documentation Index
> Fetch the complete documentation index at: https://docs.landing.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# ADE Extract Jobs

> Extract structured data asynchronously.

This endpoint creates a job that handles the processing for large markdown
documents.

For EU users, use this endpoint:

`https://api.va.eu-west-1.landing.ai/v1/ade/extract/jobs`.



## OpenAPI

````yaml /ade/va_openapi_ade2.json post /v1/ade/extract/jobs
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/extract/jobs:
    post:
      tags:
        - Tools
      summary: ADE Extract Jobs
      description: >-
        Extract structured data asynchronously.


        This endpoint creates a job that handles the processing for large
        markdown

        documents.


        For EU users, use this endpoint:


        `https://api.va.eu-west-1.landing.ai/v1/ade/extract/jobs`.
      operationId: tool_ade_extract_jobs_v1_ade_extract_jobs_post
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/AsyncExtractRequest'
      responses:
        '202':
          description: Job queued successfully
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/JobCreationResponse'
              example:
                job_id: 12345678-1234-1234-1234-123456789012
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
        '429':
          description: Rate limit exceeded
      security:
        - Basic Auth: []
      x-codeSamples:
        - lang: cURL
          label: cURL
          source: |-
            curl -X POST 'https://api.va.landing.ai/v1/ade/extract/jobs' \
              -H 'Authorization: Bearer YOUR_API_KEY' \
              -F 'schema={"type": "object", "properties": {"field1": {"type": "string"}, "field2": {"type": "string"}}}' \
              -F 'markdown=@markdown.md' \
              -F 'model=extract-latest'
        - lang: Python
          label: Python
          source: >-
            import requests


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


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


            # Read the schema file as a string

            with open('schema.json', 'r') as f:
                schema_content = f.read()

            # Prepare files and data

            files = {'markdown': open('markdown.md', 'rb')}

            data = {
                'schema': schema_content,
                'model': 'extract-latest'
            }


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

            print(response.json())
        - lang: JavaScript
          label: Node.js
          source: |-
            const axios = require('axios');
            const FormData = require('form-data');
            const fs = require('fs');

            const form = new FormData();
            form.append('markdown', fs.createReadStream('markdown.md'));
            form.append('schema', fs.readFileSync('schema.json', 'utf8'));
            form.append('model', 'extract-latest');

            axios.post('https://api.va.landing.ai/v1/ade/extract/jobs', form, {
              headers: {
                'Authorization': 'Bearer YOUR_API_KEY',
                ...form.getHeaders()
              }
            })
            .then(response => console.log(response.data))
            .catch(error => console.error(error));
components:
  schemas:
    AsyncExtractRequest:
      properties:
        model:
          anyOf:
            - type: string
            - type: 'null'
          title: Model
          description: >-
            The version of the model to use for extraction. Use `extract-latest`
            to use the latest version.
        markdown:
          anyOf:
            - type: string
              format: binary
            - type: string
            - type: 'null'
          title: Markdown
          description: The Markdown file or Markdown content to extract data from.
        markdown_url:
          anyOf:
            - type: string
            - type: 'null'
          title: Markdown Url
          description: The URL to the Markdown file to extract data from.
        schema:
          type: string
          title: Schema
          description: >-
            JSON schema for field extraction. This schema determines what
            key-values pairs are extracted from the Markdown. The schema must be
            a valid JSON object and will be validated before processing the
            document.
        strict:
          type: boolean
          title: Strict
          description: >-
            If True, reject schemas with unsupported fields (HTTP 422). If
            False, prune unsupported fields and continue. Only applies to
            extract versions that support schema validation.
          default: false
        output_save_url:
          anyOf:
            - type: string
            - type: 'null'
          title: Output Save Url
          description: >-
            If zero data retention (ZDR) is enabled, you must enter a URL for
            the extracted output to be saved to. When ZDR is enabled, the
            extracted content will not be in the API response.
      type: object
      required:
        - schema
      title: AsyncExtractRequest
      description: |-
        Request model for async extract endpoint.

        Extends ExtractRequest with output_save_url for ZDR support.
    JobCreationResponse:
      properties:
        job_id:
          type: string
          title: Job Id
      type: object
      required:
        - job_id
      title: JobCreationResponse
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError
  securitySchemes:
    Basic Auth:
      type: http
      description: >-
        Your unique API key for authentication.


        Get your API key here: https://va.landing.ai/settings/api-key.


        If using the EU endpoint, get your API key here:
        https://va.eu-west-1.landing.ai/settings/api-key.
      scheme: bearer
      bearerFormat: Basic

````