LlamaParse Platform Quickstart

Build document agents powered by agentic OCR.

LlamaParse is the enterprise platform for turning documents into production AI pipelines. One API key, one SDK, and six composable products: Parse (agentic OCR), Extract (structured data), Classify, Split, Sheets, and Index.

Using a coding agent?

Give your AI agent access to these docs: claude mcp add llama-index-docs --transport http https://developers.llamaindex.ai/mcp — More options

Install

Python

pip install llama-cloud>=2.8

TypeScript

npm install @llamaindex/llama-cloud

Go

go get github.com/run-llama/llama-parse-go

Java

implementation("ai.llamaindex:llama-cloud:1.3.0")

CLI

go install github.com/run-llama/llama-parse-cli/cmd/llp@latest

Set your API key:

export LLAMA_CLOUD_API_KEY=llx-...

Get an API key from the LlamaCloud dashboard.

---

Which product do I want?

Map what you’re trying to do to the right product:

I want to…	Use
Turn PDFs, scans, or images into clean LLM-ready text	Parse
Pull structured JSON out of documents that matches my schema	Extract
Route documents into categories with natural-language rules	Classify
Split concatenated documents into their logical parts	Split
Work with spreadsheet-like data and reason over rows	Sheets
Build a hosted vector search pipeline for RAG	Index
New here? Start with Parse—it’s the foundation most pipelines build on. Or scroll down for a runnable snippet in every product below.

---

Quick Start

Parse

Agentic OCR and parsing for 130+ formats. Turn PDFs and scans into LLM-ready text—the foundation for document agents.

Python TypeScript Go Java CLI

Copy as agent context

from llama_cloud import LlamaCloud

client = LlamaCloud()  # Uses LLAMA_CLOUD_API_KEY env var

# Upload and parse a document
file = client.files.create(file="document.pdf", purpose="parse")
result = client.parsing.parse(
    file_id=file.id,
    tier="agentic",
    version="latest",
    expand=["markdown"],
)

# Get markdown output
print(result.markdown.pages[0].markdown)

Copy as agent context

import LlamaCloud from '@llamaindex/llama-cloud';
import fs from 'fs';

const client = new LlamaCloud(); // Uses LLAMA_CLOUD_API_KEY env var

// Upload and parse a document
const file = await client.files.create({
  file: fs.createReadStream('document.pdf'),
  purpose: 'parse',
});
const result = await client.parsing.parse({
  file_id: file.id,
  tier: 'agentic',
  version: 'latest',
  expand: ['markdown']
});

// Get markdown output
console.log(result.markdown.pages[0].markdown);

Copy as agent context

package main

import (
  "context"
  "fmt"
  "log"
  "os"
  "time"

  llamacloud "github.com/run-llama/llama-parse-go"
)

func main() {
  ctx := context.Background()
  client := llamacloud.NewClient() // Uses LLAMA_CLOUD_API_KEY env var

  // Upload and parse a document
  f, err := os.Open("document.pdf")
  if err != nil {
    log.Fatal(err)
  }
  defer f.Close()

  file, err := client.Files.New(ctx, llamacloud.FileNewParams{
    File:    f,
    Purpose: "parse",
  })
  if err != nil {
    log.Fatal(err)
  }

  job, err := client.Parsing.New(ctx, llamacloud.ParsingNewParams{
    FileID:  llamacloud.String(file.ID),
    Tier:    llamacloud.ParsingNewParamsTierAgentic,
    Version: llamacloud.ParsingNewParamsVersionLatest,
  })
  if err != nil {
    log.Fatal(err)
  }

  // Poll until the job reaches a terminal state
  getParams := llamacloud.ParsingGetParams{Expand: []string{"markdown"}}
  result, err := client.Parsing.Get(ctx, job.ID, getParams)
  if err != nil {
    log.Fatal(err)
  }
  for result.Job.Status == "PENDING" || result.Job.Status == "RUNNING" {
    time.Sleep(2 * time.Second)
    result, err = client.Parsing.Get(ctx, job.ID, getParams)
    if err != nil {
      log.Fatal(err)
    }
  }

  // Get markdown output
  fmt.Println(result.Markdown.Pages[0].Markdown)
}

Copy as agent context

import ai.llamaindex.llamacloud.client.LlamaCloudClient;
import ai.llamaindex.llamacloud.client.okhttp.LlamaCloudOkHttpClient;
import ai.llamaindex.llamacloud.models.files.FileCreateParams;
import ai.llamaindex.llamacloud.models.files.FileCreateResponse;
import ai.llamaindex.llamacloud.models.parsing.ParsingCreateParams;
import ai.llamaindex.llamacloud.models.parsing.ParsingCreateResponse;
import ai.llamaindex.llamacloud.models.parsing.ParsingGetParams;
import ai.llamaindex.llamacloud.models.parsing.ParsingGetResponse;
import java.nio.file.Paths;

public class ParseQuickStart {
    public static void main(String[] args) throws Exception {
        LlamaCloudClient client = LlamaCloudOkHttpClient.fromEnv(); // Uses LLAMA_CLOUD_API_KEY env var

        // Upload and parse a document
        FileCreateResponse file = client.files().create(FileCreateParams.builder()
                .file(Paths.get("document.pdf"))
                .purpose("parse")
                .build());

        ParsingCreateResponse job = client.parsing().create(ParsingCreateParams.builder()
                .fileId(file.id())
                .tier(ParsingCreateParams.Tier.AGENTIC)
                .version(ParsingCreateParams.Version.LATEST)
                .build());

        // Poll until the job reaches a terminal state
        ParsingGetParams getParams = ParsingGetParams.builder()
                .jobId(job.id())
                .addExpand("markdown")
                .build();
        ParsingGetResponse result = client.parsing().get(getParams);
        while (result.job().status().equals(ParsingGetResponse.Job.Status.PENDING)
                || result.job().status().equals(ParsingGetResponse.Job.Status.RUNNING)) {
            Thread.sleep(2000);
            result = client.parsing().get(getParams);
        }

        // Get markdown output
        System.out.println(result.markdown().get().pages().get(0).asMarkdownResult().markdown());
    }
}

Copy as agent context

# Upload and parse a document
FILE_ID=$(llp files create --file document.pdf --purpose parse | jq -r '.id')
JOB_ID=$(llp parsing create --file-id "$FILE_ID" --tier agentic --version latest | jq -r '.id')

# Poll until the job reaches a terminal state
while true; do
  STATUS=$(llp parsing get --job-id "$JOB_ID" | jq -r '.job.status')
  case "$STATUS" in COMPLETED|FAILED|CANCELLED) break ;; esac
  sleep 2
done

# Get markdown output
llp parsing get --job-id "$JOB_ID" --expand markdown | jq -r '.markdown.pages[0].markdown'

Full Guide | Examples | Tiers & Pricing

Extract

Structured data from documents with custom schemas. Feed agents with clean entities, tables, and fields.

Python TypeScript Go Java CLI

Copy as agent context

from pydantic import BaseModel, Field
from llama_cloud import LlamaCloud

# Define your schema
class Resume(BaseModel):
    name: str = Field(description="Full name of candidate")
    email: str = Field(description="Email address")
    skills: list[str] = Field(description="Technical skills")

client = LlamaCloud()

# Upload and extract
file = client.files.create(file="resume.pdf", purpose="extract")
job = client.extract.run(
    file_input=file.id,
    configuration={
        "data_schema": Resume.model_json_schema(),
        "tier": "agentic",
    },
)
print(job.extract_result)

Copy as agent context

import LlamaCloud from '@llamaindex/llama-cloud';
import { z } from 'zod';
import fs from 'fs';

// Define your schema with Zod
const ResumeSchema = z.object({
  name: z.string().describe('Full name of candidate'),
  email: z.string().describe('Email address'),
  skills: z.array(z.string()).describe('Technical skills'),
});

const client = new LlamaCloud();

// Upload and extract
const file = await client.files.create({
  file: fs.createReadStream('resume.pdf'),
  purpose: 'extract',
});
let job = await client.extract.run({
  file_input: file.id,
  configuration: {
    data_schema: z.toJSONSchema(ResumeSchema),
    tier: 'agentic',
  },
});
console.log(job.extract_result);

Copy as agent context

package main

import (
  "context"
  "fmt"
  "log"
  "os"
  "time"

  llamacloud "github.com/run-llama/llama-parse-go"
)

func main() {
  ctx := context.Background()
  client := llamacloud.NewClient()

  // Define your schema
  dataSchema := map[string]*llamacloud.ExtractConfigurationDataSchemaUnionParam{
    "type": {OfString: llamacloud.String("object")},
    "properties": {OfAnyMap: map[string]any{
      "name":  map[string]any{"type": "string", "description": "Full name of candidate"},
      "email": map[string]any{"type": "string", "description": "Email address"},
      "skills": map[string]any{
        "type":        "array",
        "items":       map[string]any{"type": "string"},
        "description": "Technical skills",
      },
    }},
  }

  // Upload and extract
  f, err := os.Open("resume.pdf")
  if err != nil {
    log.Fatal(err)
  }
  defer f.Close()

  file, err := client.Files.New(ctx, llamacloud.FileNewParams{
    File:    f,
    Purpose: "extract",
  })
  if err != nil {
    log.Fatal(err)
  }

  job, err := client.Extract.New(ctx, llamacloud.ExtractNewParams{
    ExtractV2JobCreate: llamacloud.ExtractV2JobCreateParam{
      FileInput: file.ID,
      Configuration: llamacloud.ExtractConfigurationParam{
        DataSchema: dataSchema,
        Tier:       llamacloud.ExtractConfigurationTierAgentic,
      },
    },
  })
  if err != nil {
    log.Fatal(err)
  }

  // Poll until the job reaches a terminal state
  for job.Status == "PENDING" || job.Status == "RUNNING" {
    time.Sleep(2 * time.Second)
    job, err = client.Extract.Get(ctx, job.ID, llamacloud.ExtractGetParams{})
    if err != nil {
      log.Fatal(err)
    }
  }

  fmt.Println(job.ExtractResult.RawJSON())
}

Copy as agent context

import ai.llamaindex.llamacloud.client.LlamaCloudClient;
import ai.llamaindex.llamacloud.client.okhttp.LlamaCloudOkHttpClient;
import ai.llamaindex.llamacloud.core.JsonValue;
import ai.llamaindex.llamacloud.models.extract.ExtractConfiguration;
import ai.llamaindex.llamacloud.models.extract.ExtractCreateParams;
import ai.llamaindex.llamacloud.models.extract.ExtractGetParams;
import ai.llamaindex.llamacloud.models.extract.ExtractV2Job;
import ai.llamaindex.llamacloud.models.extract.ExtractV2JobCreate;
import ai.llamaindex.llamacloud.models.files.FileCreateParams;
import ai.llamaindex.llamacloud.models.files.FileCreateResponse;
import java.nio.file.Paths;
import java.util.Map;

public class ExtractQuickStart {
    public static void main(String[] args) throws Exception {
        LlamaCloudClient client = LlamaCloudOkHttpClient.fromEnv();

        // Define your schema
        ExtractConfiguration.DataSchema dataSchema = ExtractConfiguration.DataSchema.builder()
                .putAdditionalProperty("type", JsonValue.from("object"))
                .putAdditionalProperty("properties", JsonValue.from(Map.of(
                        "name", Map.of("type", "string", "description", "Full name of candidate"),
                        "email", Map.of("type", "string", "description", "Email address"),
                        "skills", Map.of("type", "array", "items", Map.of("type", "string"), "description", "Technical skills"))))
                .build();

        // Upload and extract
        FileCreateResponse file = client.files().create(FileCreateParams.builder()
                .file(Paths.get("resume.pdf"))
                .purpose("extract")
                .build());

        ExtractV2Job job = client.extract().create(ExtractCreateParams.builder()
                .extractV2JobCreate(ExtractV2JobCreate.builder()
                        .fileInput(file.id())
                        .configuration(ExtractConfiguration.builder()
                                .dataSchema(dataSchema)
                                .tier(ExtractConfiguration.Tier.AGENTIC)
                                .build())
                        .build())
                .build());

        // Poll until the job reaches a terminal state
        while (job.status().equals("PENDING") || job.status().equals("RUNNING")) {
            Thread.sleep(2000);
            job = client.extract().get(ExtractGetParams.builder().jobId(job.id()).build());
        }

        System.out.println(job.extractResult());
    }
}

Copy as agent context

# Define your schema
SCHEMA='{type: object, properties: {name: {type: string, description: "Full name of candidate"}, email: {type: string, description: "Email address"}, skills: {type: array, items: {type: string}, description: "Technical skills"}}}'

# Upload and extract
FILE_ID=$(llp files create --file resume.pdf --purpose extract | jq -r '.id')
JOB_ID=$(llp extract create \
  --file-input "$FILE_ID" \
  --configuration.tier agentic \
  --configuration.data-schema "$SCHEMA" | jq -r '.id')

# Poll until the job reaches a terminal state
while true; do
  JOB=$(llp extract get --job-id "$JOB_ID")
  STATUS=$(echo "$JOB" | jq -r '.status')
  case "$STATUS" in COMPLETED|FAILED|CANCELLED) break ;; esac
  sleep 2
done

echo "$JOB" | jq '.extract_result'

Full Guide | Examples | Schema Design

Classify

Beta

This feature is currently in beta.

Categorize documents with natural-language rules. Pre-processing for extraction, parsing, or indexing.

Python TypeScript Go Java CLI

Copy as agent context

from llama_cloud import LlamaCloud

client = LlamaCloud()

# Upload a document
file = client.files.create(file="document.pdf", purpose="classify")

# Classify with natural language rules
result = client.classifier.classify(
    file_ids=[file.id],
    rules=[
        {
            "type": "invoice",
            "description": "Documents with invoice numbers, line items, and totals"
        },
        {
            "type": "receipt",
            "description": "Short POS receipts with merchant and total"
        },
        {
            "type": "contract",
            "description": "Legal agreements with terms and signatures"
        },
    ],
    mode="FAST",  # or "MULTIMODAL" for visual docs
)

for item in result.items:
    print(f"Type: {item.result.type}, Confidence: {item.result.confidence}")

Copy as agent context

import LlamaCloud from '@llamaindex/llama-cloud';
import fs from 'fs';

const client = new LlamaCloud();

// Upload a document
const file = await client.files.create({
  file: fs.createReadStream('document.pdf'),
  purpose: 'classify',
});

// Classify with natural language rules
const result = await client.classifier.classify({
  file_ids: [file.id],
  rules: [
    {
      type: 'invoice',
      description: 'Documents with invoice numbers, line items, and totals',
    },
    {
      type: 'receipt',
      description: 'Short POS receipts with merchant and total',
    },
    {
      type: 'contract',
      description: 'Legal agreements with terms and signatures',
    },
  ],
  mode: 'FAST', // or 'MULTIMODAL' for visual docs
});

for (const item of result.items) {
  if (item.result) {
    console.log(`Type: ${item.result.type}, Confidence: ${item.result.confidence}`);
  }
}

Copy as agent context

package main

import (
  "context"
  "fmt"
  "log"
  "os"
  "time"

  llamacloud "github.com/run-llama/llama-parse-go"
)

func main() {
  ctx := context.Background()
  client := llamacloud.NewClient()

  // Upload a document
  f, err := os.Open("document.pdf")
  if err != nil {
    log.Fatal(err)
  }
  defer f.Close()

  file, err := client.Files.New(ctx, llamacloud.FileNewParams{
    File:    f,
    Purpose: "classify",
  })
  if err != nil {
    log.Fatal(err)
  }

  // Classify with natural language rules
  job, err := client.Classifier.Jobs.New(ctx, llamacloud.ClassifierJobNewParams{
    FileIDs: []string{file.ID},
    Rules: []llamacloud.ClassifierRuleParam{
      {Type: "invoice", Description: "Documents with invoice numbers, line items, and totals"},
      {Type: "receipt", Description: "Short POS receipts with merchant and total"},
      {Type: "contract", Description: "Legal agreements with terms and signatures"},
    },
    Mode: llamacloud.ClassifierJobNewParamsModeFast, // or Multimodal for visual docs
  })
  if err != nil {
    log.Fatal(err)
  }

  // Poll until the job reaches a terminal state
  for job.Status == llamacloud.StatusEnumPending {
    time.Sleep(2 * time.Second)
    job, err = client.Classifier.Jobs.Get(ctx, job.ID, llamacloud.ClassifierJobGetParams{})
    if err != nil {
      log.Fatal(err)
    }
  }

  result, err := client.Classifier.Jobs.GetResults(ctx, job.ID, llamacloud.ClassifierJobGetResultsParams{})
  if err != nil {
    log.Fatal(err)
  }
  for _, item := range result.Items {
    fmt.Printf("Type: %s, Confidence: %v\n", item.Result.Type, item.Result.Confidence)
  }
}

Copy as agent context

import ai.llamaindex.llamacloud.client.LlamaCloudClient;
import ai.llamaindex.llamacloud.client.okhttp.LlamaCloudOkHttpClient;
import ai.llamaindex.llamacloud.models.classifier.jobs.ClassifierRule;
import ai.llamaindex.llamacloud.models.classifier.jobs.ClassifyJob;
import ai.llamaindex.llamacloud.models.classifier.jobs.JobCreateParams;
import ai.llamaindex.llamacloud.models.classifier.jobs.JobGetResultsResponse;
import ai.llamaindex.llamacloud.models.files.FileCreateParams;
import ai.llamaindex.llamacloud.models.files.FileCreateResponse;
import ai.llamaindex.llamacloud.models.parsing.StatusEnum;
import java.nio.file.Paths;

public class ClassifyQuickStart {
    public static void main(String[] args) throws Exception {
        LlamaCloudClient client = LlamaCloudOkHttpClient.fromEnv();

        // Upload a document
        FileCreateResponse file = client.files().create(FileCreateParams.builder()
                .file(Paths.get("document.pdf"))
                .purpose("classify")
                .build());

        // Classify with natural language rules
        ClassifyJob job = client.classifier().jobs().create(JobCreateParams.builder()
                .addFileId(file.id())
                .addRule(ClassifierRule.builder()
                        .type("invoice")
                        .description("Documents with invoice numbers, line items, and totals")
                        .build())
                .addRule(ClassifierRule.builder()
                        .type("receipt")
                        .description("Short POS receipts with merchant and total")
                        .build())
                .addRule(ClassifierRule.builder()
                        .type("contract")
                        .description("Legal agreements with terms and signatures")
                        .build())
                .mode(JobCreateParams.Mode.FAST) // or MULTIMODAL for visual docs
                .build());

        // Poll until the job reaches a terminal state
        while (job.status().equals(StatusEnum.PENDING)) {
            Thread.sleep(2000);
            job = client.classifier().jobs().get(job.id());
        }

        JobGetResultsResponse results = client.classifier().jobs().getResults(job.id());
        for (JobGetResultsResponse.Item item : results.items()) {
            item.result().ifPresent(r ->
                    System.out.println("Type: " + r.type().orElse("") + ", Confidence: " + r.confidence()));
        }
    }
}

Copy as agent context

# Upload a document
FILE_ID=$(llp files create --file document.pdf --purpose classify | jq -r '.id')

# Classify with natural language rules
JOB_ID=$(llp classifier:jobs create \
  --file-id "$FILE_ID" \
  --rule '{type: invoice, description: "Documents with invoice numbers, line items, and totals"}' \
  --rule '{type: receipt, description: "Short POS receipts with merchant and total"}' \
  --rule '{type: contract, description: "Legal agreements with terms and signatures"}' \
  --mode FAST | jq -r '.id')

# Poll until the job reaches a terminal state
while true; do
  STATUS=$(llp classifier:jobs get --classify-job-id "$JOB_ID" | jq -r '.status')
  [ "$STATUS" = "PENDING" ] || break
  sleep 2
done

llp classifier:jobs get-results --classify-job-id "$JOB_ID" | jq -r '.items[].result | .type, .confidence'

Full Guide | Examples

Split

Beta

This feature is currently in beta.

Segment concatenated PDFs into logical sections. AI-powered classification to split combined documents.

Python TypeScript Go Java CLI

Copy as agent context

from llama_cloud import LlamaCloud

client = LlamaCloud()

# Upload a combined PDF
file = client.files.create(file="combined.pdf", purpose="split")

# Split into logical sections
result = await client.beta.split.split(
    categories=[
        {
            "name": "invoice",
            "description": "Commercial document with line items and totals"
        },
        {
            "name": "contract",
            "description": "Legal agreement with terms and signatures"
        },
    ],
    document_input={"type": "file_id", "value": file.id},
)

for segment in result.result.segments:
    print(f"Pages {segment.pages}: {segment.category} ({segment.confidence_category})")

Copy as agent context

import LlamaCloud from '@llamaindex/llama-cloud';
import fs from 'fs';

const client = new LlamaCloud();

// Upload a combined PDF
const file = await client.files.create({
  file: fs.createReadStream('combined.pdf'),
  purpose: 'split',
});

// Split into logical sections
const result = await client.beta.split.split({
  categories: [
    {
      name: 'invoice',
      description: 'Commercial document with line items and totals',
    },
    {
      name: 'contract',
      description: 'Legal agreement with terms and signatures',
    },
  ],
  document_input: { type: 'file_id', value: file.id },
});

for (const segment of result.result.segments) {
  console.log(`Pages ${segment.pages}: ${segment.category} (${segment.confidence_category})`);
}

Copy as agent context

package main

import (
  "context"
  "fmt"
  "log"
  "os"
  "time"

  llamacloud "github.com/run-llama/llama-parse-go"
)

func main() {
  ctx := context.Background()
  client := llamacloud.NewClient()

  // Upload a combined PDF
  f, err := os.Open("combined.pdf")
  if err != nil {
    log.Fatal(err)
  }
  defer f.Close()

  file, err := client.Files.New(ctx, llamacloud.FileNewParams{
    File:    f,
    Purpose: "split",
  })
  if err != nil {
    log.Fatal(err)
  }

  // Split into logical sections
  job, err := client.Beta.Split.New(ctx, llamacloud.BetaSplitNewParams{
    DocumentInput: llamacloud.SplitDocumentInputParam{Type: "file_id", Value: file.ID},
    Configuration: llamacloud.BetaSplitNewParamsConfiguration{
      Categories: []llamacloud.SplitCategoryParam{
        {Name: "invoice", Description: llamacloud.String("Commercial document with line items and totals")},
        {Name: "contract", Description: llamacloud.String("Legal agreement with terms and signatures")},
      },
    },
  })
  if err != nil {
    log.Fatal(err)
  }

  // Poll until the job reaches a terminal state (Split statuses are lowercase)
  result, err := client.Beta.Split.Get(ctx, job.ID, llamacloud.BetaSplitGetParams{})
  if err != nil {
    log.Fatal(err)
  }
  for result.Status == "pending" || result.Status == "processing" {
    time.Sleep(2 * time.Second)
    result, err = client.Beta.Split.Get(ctx, job.ID, llamacloud.BetaSplitGetParams{})
    if err != nil {
      log.Fatal(err)
    }
  }

  for _, segment := range result.Result.Segments {
    fmt.Printf("Pages %v: %s (%s)\n", segment.Pages, segment.Category, segment.ConfidenceCategory)
  }
}

Copy as agent context

import ai.llamaindex.llamacloud.client.LlamaCloudClient;
import ai.llamaindex.llamacloud.client.okhttp.LlamaCloudOkHttpClient;
import ai.llamaindex.llamacloud.models.beta.split.SplitCategory;
import ai.llamaindex.llamacloud.models.beta.split.SplitCreateParams;
import ai.llamaindex.llamacloud.models.beta.split.SplitCreateResponse;
import ai.llamaindex.llamacloud.models.beta.split.SplitDocumentInput;
import ai.llamaindex.llamacloud.models.beta.split.SplitGetResponse;
import ai.llamaindex.llamacloud.models.beta.split.SplitSegmentResponse;
import ai.llamaindex.llamacloud.models.files.FileCreateParams;
import ai.llamaindex.llamacloud.models.files.FileCreateResponse;
import java.nio.file.Paths;

public class SplitQuickStart {
    public static void main(String[] args) throws Exception {
        LlamaCloudClient client = LlamaCloudOkHttpClient.fromEnv();

        // Upload a combined PDF
        FileCreateResponse file = client.files().create(FileCreateParams.builder()
                .file(Paths.get("combined.pdf"))
                .purpose("split")
                .build());

        // Split into logical sections
        SplitCreateResponse job = client.beta().split().create(SplitCreateParams.builder()
                .documentInput(SplitDocumentInput.builder().type("file_id").value(file.id()).build())
                .configuration(SplitCreateParams.Configuration.builder()
                        .addCategory(SplitCategory.builder()
                                .name("invoice")
                                .description("Commercial document with line items and totals")
                                .build())
                        .addCategory(SplitCategory.builder()
                                .name("contract")
                                .description("Legal agreement with terms and signatures")
                                .build())
                        .build())
                .build());

        // Poll until the job reaches a terminal state (Split statuses are lowercase)
        SplitGetResponse result = client.beta().split().get(job.id());
        while (result.status().equals("pending") || result.status().equals("processing")) {
            Thread.sleep(2000);
            result = client.beta().split().get(job.id());
        }

        for (SplitSegmentResponse segment : result.result().get().segments()) {
            System.out.println("Pages " + segment.pages() + ": " + segment.category()
                    + " (" + segment.confidenceCategory() + ")");
        }
    }
}

Copy as agent context

# Upload a combined PDF
FILE_ID=$(llp files create --file combined.pdf --purpose split | jq -r '.id')

# Split into logical sections
JOB_ID=$(llp beta:split create \
  --document-input "{type: file_id, value: $FILE_ID}" \
  --configuration '{categories: [{name: invoice, description: "Commercial document with line items and totals"}, {name: contract, description: "Legal agreement with terms and signatures"}]}' \
  | jq -r '.id')

# Poll until the job reaches a terminal state (Split statuses are lowercase)
while true; do
  STATUS=$(llp beta:split get --split-job-id "$JOB_ID" | jq -r '.status')
  case "$STATUS" in completed|failed|cancelled) break ;; esac
  sleep 2
done

llp beta:split get --split-job-id "$JOB_ID" | jq -c '.result.segments[]'

Full Guide | Examples

Sheets

Beta

This feature is currently in beta.

Extract tables and metadata from messy spreadsheets. Output as Parquet files with rich cell metadata.

Python TypeScript Go Java CLI

Copy as agent context

from llama_cloud import LlamaCloud

client = LlamaCloud()

# Upload a spreadsheet
file = client.files.create(file="spreadsheet.xlsx", purpose="parse")

# Extract tables and regions
result = client.beta.sheets.parse(
    file_id=file.id,
    config={"generate_additional_metadata": True},
)

# Print extracted regions
print(f"Found {len(result.regions)} regions")
for region in result.regions:
    print(f"  - {region.region_id}: {region.title} ({region.location})")

Copy as agent context

import LlamaCloud from '@llamaindex/llama-cloud';
import fs from 'fs';

const client = new LlamaCloud();

// Upload a spreadsheet
const file = await client.files.create({
  file: fs.createReadStream('spreadsheet.xlsx'),
  purpose: 'parse',
});

// Extract tables and regions
const result = await client.beta.sheets.parse({
  file_id: file.id,
  config: { generate_additional_metadata: true },
});

// Print extracted regions
console.log(`Found ${result.regions?.length || 0} regions`);
for (const region of result.regions || []) {
  console.log(`  - ${region.region_id}: ${region.title} (${region.location})`);
}

Copy as agent context

package main

import (
  "context"
  "fmt"
  "log"
  "os"
  "time"

  llamacloud "github.com/run-llama/llama-parse-go"
)

func main() {
  ctx := context.Background()
  client := llamacloud.NewClient()

  // Upload a spreadsheet
  f, err := os.Open("spreadsheet.xlsx")
  if err != nil {
    log.Fatal(err)
  }
  defer f.Close()

  file, err := client.Files.New(ctx, llamacloud.FileNewParams{
    File:    f,
    Purpose: "parse",
  })
  if err != nil {
    log.Fatal(err)
  }

  // Extract tables and regions
  job, err := client.Beta.Sheets.New(ctx, llamacloud.BetaSheetNewParams{
    FileID: file.ID,
    Config: llamacloud.SheetsParsingConfigParam{
      GenerateAdditionalMetadata: llamacloud.Bool(true),
    },
  })
  if err != nil {
    log.Fatal(err)
  }

  // Poll until the job reaches a terminal state
  getParams := llamacloud.BetaSheetGetParams{IncludeResults: llamacloud.Bool(true)}
  result, err := client.Beta.Sheets.Get(ctx, job.ID, getParams)
  if err != nil {
    log.Fatal(err)
  }
  for result.Status == llamacloud.SheetsJobStatusPending {
    time.Sleep(3 * time.Second)
    result, err = client.Beta.Sheets.Get(ctx, job.ID, getParams)
    if err != nil {
      log.Fatal(err)
    }
  }

  // Print extracted regions
  fmt.Printf("Found %d regions\n", len(result.Regions))
  for _, region := range result.Regions {
    fmt.Printf("  - %s: %s (%s)\n", region.RegionID, region.Title, region.Location)
  }
}

Copy as agent context

import ai.llamaindex.llamacloud.client.LlamaCloudClient;
import ai.llamaindex.llamacloud.client.okhttp.LlamaCloudOkHttpClient;
import ai.llamaindex.llamacloud.models.beta.sheets.SheetCreateParams;
import ai.llamaindex.llamacloud.models.beta.sheets.SheetGetParams;
import ai.llamaindex.llamacloud.models.beta.sheets.SheetsJob;
import ai.llamaindex.llamacloud.models.beta.sheets.SheetsParsingConfig;
import ai.llamaindex.llamacloud.models.files.FileCreateParams;
import ai.llamaindex.llamacloud.models.files.FileCreateResponse;
import java.nio.file.Paths;
import java.util.List;

public class SheetsQuickStart {
    public static void main(String[] args) throws Exception {
        LlamaCloudClient client = LlamaCloudOkHttpClient.fromEnv();

        // Upload a spreadsheet
        FileCreateResponse file = client.files().create(FileCreateParams.builder()
                .file(Paths.get("spreadsheet.xlsx"))
                .purpose("parse")
                .build());

        // Extract tables and regions
        SheetsJob job = client.beta().sheets().create(SheetCreateParams.builder()
                .fileId(file.id())
                .configuration(SheetsParsingConfig.builder().generateAdditionalMetadata(true).build())
                .build());

        // Poll until the job reaches a terminal state
        SheetGetParams getParams = SheetGetParams.builder()
                .spreadsheetJobId(job.id())
                .includeResults(true)
                .build();
        SheetsJob result = client.beta().sheets().get(getParams);
        while (result.status().equals(SheetsJob.Status.PENDING)) {
            Thread.sleep(3000);
            result = client.beta().sheets().get(getParams);
        }

        // Print extracted regions
        List<SheetsJob.Region> regions = result.regions().orElse(List.of());
        System.out.println("Found " + regions.size() + " regions");
        for (SheetsJob.Region region : regions) {
            System.out.println("  - " + region.regionId().orElse("") + ": "
                    + region.title().orElse("") + " (" + region.location() + ")");
        }
    }
}

Copy as agent context

# Upload a spreadsheet
FILE_ID=$(llp files create --file spreadsheet.xlsx --purpose parse | jq -r '.id')

# Extract tables and regions
JOB_ID=$(llp beta:sheets create \
  --file-id "$FILE_ID" \
  --config '{generate_additional_metadata: true}' | jq -r '.id')

# Poll until the job reaches a terminal state
while true; do
  STATUS=$(llp beta:sheets get --spreadsheet-job-id "$JOB_ID" | jq -r '.status')
  [ "$STATUS" = "PENDING" ] || break
  sleep 3
done

# Print extracted regions
llp beta:sheets get --spreadsheet-job-id "$JOB_ID" --include-results \
  | jq -r '.regions // [] | "Found \(length) regions", (.[] | "  - \(.region_id): \(.title) (\(.location))")'

Full Guide | Examples

Index

Ingest, chunk, and embed into searchable indexes. Power RAG and retrieval for document agents. Index is designed for UI-first setup with SDK integration. Start in the LlamaCloud dashboard to create your index, then integrate:

Python TypeScript Go Java CLI

Copy as agent context

from llama_cloud import LlamaCloud

client = LlamaCloud()  # Uses LLAMA_CLOUD_API_KEY env var

# Retrieve relevant nodes from the index
results = client.pipelines.retrieve(
    pipeline_id="your-pipeline-id",
    query="Your query here",
    # -- Customize search behavior --
    # dense_similarity_top_k=20,
    # sparse_similarity_top_k=20,
    # alpha=0.5,
    # -- Control reranking behavior --
    # enable_reranking=True,
    # rerank_top_n=5,
)

for n in results.retrieval_nodes:
    print(f"Score: {n.score}, Text: {n.node.text}")

Copy as agent context

import LlamaCloud from '@llamaindex/llama-cloud';

const client = new LlamaCloud(); // Uses LLAMA_CLOUD_API_KEY env var

// Retrieve relevant nodes from the index
const results = await client.pipelines.retrieve('your-pipeline-id', {
  query: 'Your query here',
  // -- Customize search behavior --
  // dense_similarity_top_k: 20,
  // sparse_similarity_top_k: 20,
  // alpha: 0.5,
  // -- Control reranking behavior --
  // enable_reranking: true,
  // rerank_top_n: 5,
});

for (const node of results.retrieval_nodes || []) {
  console.log(`Score: ${node.score}, Text: ${node.node?.text}`);
}

Copy as agent context

package main

import (
  "context"
  "fmt"
  "log"

  llamacloud "github.com/run-llama/llama-parse-go"
)

func main() {
  ctx := context.Background()
  client := llamacloud.NewClient() // Uses LLAMA_CLOUD_API_KEY env var

  // Retrieve relevant nodes from the index
  results, err := client.Pipelines.RunSearch(ctx, "your-pipeline-id", llamacloud.PipelineRunSearchParams{
    Query: "Your query here",
    // -- Customize search behavior --
    // DenseSimilarityTopK:  llamacloud.Int(20),
    // SparseSimilarityTopK: llamacloud.Int(20),
    // Alpha:                llamacloud.Float(0.5),
    // -- Control reranking behavior --
    // EnableReranking: llamacloud.Bool(true),
    // RerankTopN:      llamacloud.Int(5),
  })
  if err != nil {
    log.Fatal(err)
  }

  for _, n := range results.RetrievalNodes {
    fmt.Printf("Score: %v, Text: %s\n", n.Score, n.Node.Text)
  }
}

Copy as agent context

import ai.llamaindex.llamacloud.client.LlamaCloudClient;
import ai.llamaindex.llamacloud.client.okhttp.LlamaCloudOkHttpClient;
import ai.llamaindex.llamacloud.models.pipelines.PipelineRetrieveParams;
import ai.llamaindex.llamacloud.models.pipelines.PipelineRetrieveResponse;

public class IndexQuickStart {
    public static void main(String[] args) throws Exception {
        LlamaCloudClient client = LlamaCloudOkHttpClient.fromEnv(); // Uses LLAMA_CLOUD_API_KEY env var

        // Retrieve relevant nodes from the index
        PipelineRetrieveResponse results = client.pipelines().retrieve(
                PipelineRetrieveParams.builder()
                        .pipelineId("your-pipeline-id")
                        .query("Your query here")
                        // -- Customize search behavior --
                        // .denseSimilarityTopK(20)
                        // .sparseSimilarityTopK(20)
                        // .alpha(0.5)
                        // -- Control reranking behavior --
                        // .enableReranking(true)
                        // .rerankTopN(5)
                        .build());

        for (PipelineRetrieveResponse.RetrievalNode n : results.retrievalNodes()) {
            System.out.println("Score: " + n.score().orElse(null) + ", Text: " + n.node().text().orElse(""));
        }
    }
}

Copy as agent context

# Retrieve relevant nodes from the index
llp pipelines run-search \
  --pipeline-id "your-pipeline-id" \
  --query "Your query here" \
  | jq -c '.retrieval_nodes[] | {score, text: .node.text}'

# Customize search behavior with --dense-similarity-top-k, --sparse-similarity-top-k,
# --alpha, and control reranking with --enable-reranking and --rerank-top-n.

Full Guide | Examples

---

LlamaParse Agent Skills

Download Skills

Available Skills

• llamaparse: Advanced parsing for PDFs, docs, presentations and images (charts, tables, embedded visuals). Requires LLAMA_CLOUD_API_KEY and Node 18+.
• liteparse: Local-first, fast parsing for text-dense PDFs and docs. No API key needed, requires @llamaindex/liteparse globally installed and Node 18+.

Installation

You can install LlamaParse Agent Skills using the skills CLI:

npx skills add run-llama/llamaparse-agent-skills

Or, if you wish to download only one skill:

npx skills add run-llama/llamaparse-agent-skills --skill llamaparse # or the name of another skill

You can also download the skills folder in .zip format from GitHub Releases.

---

Resources

Python SDK pip install llama-cloud>=2.8

TypeScript SDK npm install @llamaindex/llama-cloud

Go SDK go get github.com/run-llama/llama-parse-go

Java SDK implementation("ai.llamaindex:llama-cloud:1.3.0")

CLI go install github.com/run-llama/llama-parse-cli/cmd/llp@latest