> ## 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.

# Quickstart

> Parse your first document as a Parse Job on the standard tier and get structured Markdown back.

Get started with the [Parse API](https://docs.landing.ai/api-reference/parse/ade-parse) by parsing a <a href="/examples/kyc-form.pdf" download="kyc-form.pdf">sample customer due diligence form</a>. You submit the document as a [Parse Job](./parse-async), then collect a structured Markdown rendering of it, ready for downstream workflows like RAG, search, or extraction.

If you would rather not write the request yourself, the [CLI Quickstart](/cli/quickstart) gets the same result in two commands.

## Prerequisites

* An Agentic Document Extraction [account](https://ade.landing.ai/)
* An [API key](./agentic-api-key)

## Tutorial: Parse a Document

<Tabs>
  <Tab title="Python">
    <Steps>
      <Step title="Set the API key as an environment variable">
        The library reads your [API key](./agentic-api-key) from the `VISION_AGENT_API_KEY` environment variable.

        <CodeGroup>
          ```bash macOS/Linux theme={null}
          export VISION_AGENT_API_KEY="<your-api-key>"
          ```

          ```cmd Windows (Command Prompt) theme={null}
          set "VISION_AGENT_API_KEY=<your-api-key>"
          ```

          ```powershell Windows (PowerShell) theme={null}
          $env:VISION_AGENT_API_KEY="<your-api-key>"
          ```
        </CodeGroup>
      </Step>

      <Step title="Install the Python library">
        Install the [ade-python](https://github.com/landing-ai/ade-python) library.

        ```bash theme={null}
        pip install landingai-ade
        ```
      </Step>

      <Step title="Create your code">
        The `wait` method polls the job for you and returns it once it reaches a terminal state. Save the code block below as `parse.py`.

        ```python theme={null}
        from landingai_ade import LandingAIADE

        client = LandingAIADE()

        job = client.v2.parse_jobs.create(
            document_url="https://docs.landing.ai/examples/kyc-form.pdf",
            service_tier="standard",
        )
        done = client.v2.parse_jobs.wait(job.job_id, raise_on_failure=True)

        with open("markdown-kyc-form.md", "w") as f:
            f.write(done.result.markdown)
        ```
      </Step>

      <Step title="Run your code">
        Run the file you created. The script saves the parsed Markdown to `markdown-kyc-form.md` in the current directory.

        ```bash theme={null}
        python3 parse.py
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="TypeScript">
    <Steps>
      <Step title="Set the API key as an environment variable">
        The library reads your [API key](./agentic-api-key) from the `VISION_AGENT_API_KEY` environment variable.

        <CodeGroup>
          ```bash macOS/Linux theme={null}
          export VISION_AGENT_API_KEY="<your-api-key>"
          ```

          ```cmd Windows (Command Prompt) theme={null}
          set "VISION_AGENT_API_KEY=<your-api-key>"
          ```

          ```powershell Windows (PowerShell) theme={null}
          $env:VISION_AGENT_API_KEY="<your-api-key>"
          ```
        </CodeGroup>
      </Step>

      <Step title="Install the TypeScript library">
        Install the [ade-typescript](https://github.com/landing-ai/ade-typescript) library.

        ```bash theme={null}
        npm install landingai-ade
        ```
      </Step>

      <Step title="Create your code">
        The `wait` method polls the job for you and returns it once it reaches a terminal state. Save the code block below as `parse.ts`.

        ```typescript theme={null}
        import fs from "fs";
        import LandingAIADE from "landingai-ade";

        const client = new LandingAIADE();

        const job = await client.v2.parseJobs.create({
          document_url: "https://docs.landing.ai/examples/kyc-form.pdf",
          service_tier: "standard",
        });
        const done = await client.v2.parseJobs.wait(job.job_id, { raiseOnFailure: true });
        const parsed = done.result as LandingAIADE.V2ParseResponse;

        if (!parsed.markdown) {
          throw new Error(`Job ${job.job_id} returned no Markdown (status: ${done.status}).`);
        }
        fs.writeFileSync("markdown-kyc-form.md", parsed.markdown);
        ```
      </Step>

      <Step title="Run your code">
        Run the file you created. The script saves the parsed Markdown to `markdown-kyc-form.md` in the current directory.

        ```bash theme={null}
        npx tsx parse.ts
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="cURL">
    <Steps>
      <Step title="Install jq">
        Install [jq](https://jqlang.org/), a free third-party command-line tool that reads values out of the JSON responses. Some common install instructions are below; to see all installation methods, go to the [jq site](https://jqlang.org/download/).

        <CodeGroup>
          ```bash Mac theme={null}
          brew install jq
          ```

          ```bash Windows theme={null}
          winget install jqlang.jq
          ```

          ```bash Linux theme={null}
          sudo apt-get install jq
          ```
        </CodeGroup>
      </Step>

      <Step title="Create the parse job">
        Submit the document and capture the `job_id` from the response into a shell variable. Replace `YOUR_API_KEY` with your [API key](./agentic-api-key).

        ```bash theme={null}
        JOB_ID=$(curl -s -X POST 'https://api.ade.landing.ai/v2/parse/jobs' \
          -H 'Authorization: Bearer YOUR_API_KEY' \
          -F 'document_url=https://docs.landing.ai/examples/kyc-form.pdf' \
          -F 'service_tier=standard' | jq -r .job_id)
        ```

        The request returns a `202` response carrying the `job_id`, the job's status, and its creation time:

        ```json theme={null}
        {
          "job_id": "parse-01m1cn0y1k88schxxtgz97vpw2",
          "status": "pending",
          "created_at": "2026-08-31T19:34:01.015456+00:00"
        }
        ```
      </Step>

      <Step title="Collect the result">
        Fetch the job and save the response to `parse-output.json`. Re-run this command until `status` reads `completed`. If it reads `failed`, stop and check the `error` field for the reason.

        ```bash theme={null}
        curl -s "https://api.ade.landing.ai/v2/parse/jobs/$JOB_ID" \
          -H 'Authorization: Bearer YOUR_API_KEY' > parse-output.json

        jq -r .status parse-output.json
        ```
      </Step>

      <Step title="Save the Markdown content">
        A finished job nests the parse output under `result`, so the Markdown is at `.result.markdown`. Save it to a file called `markdown-kyc-form.md`.

        ```bash theme={null}
        jq -r .result.markdown parse-output.json > markdown-kyc-form.md
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Use the Markdown

Open `markdown-kyc-form.md`. It holds the form as reading-order Markdown, ready for a RAG application, a search index, or an LLM prompt. To pull named fields out of it instead, pass it to [Extract](./extract).

## What's Next

<CardGroup cols={2}>
  <Card title="How Parse Works" icon="diagram-project" href="./parse">
    Understand the response shape in depth: pages, blocks, and grounding.
  </Card>

  <Card title="Extract Data" icon="table-list" href="./extract">
    Pull named fields out of this Markdown with a schema.
  </Card>

  <Card title="Credit Consumption" icon="coins" href="./credit-consumption">
    See how credit usage is calculated per page.
  </Card>

  <Card title="Troubleshoot" icon="circle-question" href="./parse-troubleshoot">
    Status codes, errors, and how to resolve them.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.