Retrieving Results

expand controls what comes back from a Parse job. By default the API returns only the job itself (status, ID, error message), no parsed content. You add expand values to opt in to the data you want, and you can ask for a different set later against the same job without re-parsing.

This page shows how to use expand: every value, the patterns most callers use, and the limits. For what each returned field contains, see the response format.

Quick lookup

Inline content

These return parsed data in the response body, no download step.

Value	What you get	Notes
markdown	Markdown per page
markdown_full	The whole document as one markdown string
text	Plain text per page
text_full	The whole document as one plain-text string
items	Structured items per page: tables, headings, figures, lists
metadata	Per-page metadata: confidence, orientation, watermark, speaker notes
forms	Per-page form trees (beta)	Jobs with processing_options.forms: "enrich" only; never on fast
job_metadata	Job execution metadata: state transitions and timing
usage	Credits billed, under job.usage	See Credits billed for a job

Download URLs

These add a presigned download URL under result_content_metadata instead of returning the content. Use them when the result is large and you want to check its size first, stream it to storage, or fetch a file format such as XLSX or PDF. The entry shape and the file each one yields are in Download URLs.

Value	File	Notes
markdown_content_metadata	Per-page markdown, JSON
markdown_full_content_metadata	The whole document as one .md
text_content_metadata	Per-page text, JSON
text_full_content_metadata	The whole document as one .txt
items_content_metadata	Items tree, JSON
metadata_content_metadata	Page metadata, JSON
forms_content_metadata	Forms, JSON	Jobs with processing_options.forms: "enrich" only
images_content_metadata	Saved images, each with its own URL	Which images exist depends on output_options.images_to_save
xlsx_content_metadata	Tables as a workbook	Jobs with tables_as_spreadsheet.enable: true only
output_pdf_content_metadata	The rendered PDF	Jobs with output_options.save_output_pdf: true only
raw_words_content_metadata	Word-level boxes, JSONL	Jobs with output_options.additional_outputs: ["word_bbox"] only
result_content_metadata.grounded_items	Grounded items sidecar, JSONL	Included automatically when granular_bboxes is set; nothing to add to expand

Every value works on every tier, with two exceptions: forms needs the form pass, which the fast tier does not run, and a fast job pinned to a version older than 2026-06-15 has no markdown or items at all. See Limitations.

Common patterns

The SDK snippets below assume a client and an uploaded file, as in the quickstart. Per-page results can contain a failed page ("success": false) with no content fields, so the loops check success before reading; see Page arrays.

Just give me the markdown

The simplest pattern. Most LLM pipelines only need this.

Python

result = client.parsing.parse(
    file_id=file.id,
    tier="agentic",
    version="latest",
    expand=["markdown"],
)

for page in result.markdown.pages:
    if page.success:
        print(page.markdown)

TypeScript

const result = await client.parsing.parse({
  file_id: file.id,
  tier: "agentic",
  version: "latest",
  expand: ["markdown"],
});

for (const page of result.markdown?.pages ?? []) {
  if (page.success) {
    console.log(page.markdown);
  }
}

Go

// expand is a GET parameter in Go, so create the job, poll, then request markdown
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)
}

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 != "COMPLETED" && result.Job.Status != "FAILED" && result.Job.Status != "CANCELLED" {
  time.Sleep(2 * time.Second)
  result, err = client.Parsing.Get(ctx, job.ID, getParams)
  if err != nil {
    log.Fatal(err)
  }
}
if result.Job.Status != "COMPLETED" {
  log.Fatalf("parse ended as %s", result.Job.Status)
}

for _, page := range result.Markdown.Pages {
  if page.Success {
    fmt.Println(page.Markdown)
  }
}

Java

// expand is a query parameter in Java, so create the job, poll, then request markdown
ParsingCreateResponse job = client.parsing().create(ParsingCreateParams.builder()
        .fileId(file.id())
        .tier(ParsingCreateParams.Tier.AGENTIC)
        .version(ParsingCreateParams.Version.LATEST)
        .build());

ParsingGetParams getParams = ParsingGetParams.builder()
        .jobId(job.id())
        .addExpand("markdown")
        .build();

ParsingGetResponse result = client.parsing().get(getParams);
while (!result.job().status().equals(ParsingGetResponse.Job.Status.COMPLETED)
        && !result.job().status().equals(ParsingGetResponse.Job.Status.FAILED)
        && !result.job().status().equals(ParsingGetResponse.Job.Status.CANCELLED)) {
    Thread.sleep(2000);
    result = client.parsing().get(getParams);
}
if (!result.job().status().equals(ParsingGetResponse.Job.Status.COMPLETED)) {
    throw new RuntimeException("parse ended as " + result.job().status());
}

for (ParsingGetResponse.Markdown.Page page : result.markdown().get().pages()) {
    if (page.isMarkdownResult()) {
        System.out.println(page.asMarkdownResult().markdown());
    }
}

CLI

JOB_ID=$(llp parsing create \
  --file-id "$FILE_ID" \
  --tier agentic \
  --version latest \
  | jq -r '.id')

# Poll until the job reaches a terminal status
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

# expand is a query parameter — request markdown when you fetch the result
llp parsing get --job-id "$JOB_ID" --expand markdown \
  | jq -r '.markdown.pages[] | select(.success) | .markdown'

Don't need per-page markdown?

If you just want the full document as one string, use expand=["markdown_full"] instead: it returns result.markdown_full directly and avoids the per-page loop.

Markdown plus the structured items tree

For pipelines that need programmatic access to tables, headings, and figures. Items already include an md field per element, so you can build LLM input from items alone, but requesting markdown alongside gives you a ready-made per-page markdown string without reassembling it.

Python

result = client.parsing.parse(
    file_id=file.id,
    tier="agentic",
    version="latest",
    expand=["markdown", "items"],
)

# Per-page markdown for the LLM (or use markdown_full for a single string)
llm_input = "\n\n".join(p.markdown for p in result.markdown.pages if p.success)

# Walk the items tree for tables
for page in result.items.pages:
    if not page.success:
        continue
    for item in page.items:
        if item.type == "table":
            print(f"Table on page {page.page_number}: {len(item.rows)} rows")

TypeScript

const result = await client.parsing.parse({
  file_id: file.id,
  tier: "agentic",
  version: "latest",
  expand: ["markdown", "items"],
});

// Per-page markdown for the LLM (or use markdown_full for a single string)
const llmInput = (result.markdown?.pages ?? [])
  .filter((p) => p.success)
  .map((p) => p.markdown)
  .join("\n\n");

// Walk the items tree for tables
for (const page of result.items?.pages ?? []) {
  if (!page.success) continue;
  for (const item of page.items) {
    if (item.type === "table") {
      console.log(`Table on page ${page.page_number}: ${item.rows.length} rows`);
    }
  }
}

Go

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)
}

// expand is a GET parameter — request markdown and items when you fetch the result
getParams := llamacloud.ParsingGetParams{Expand: []string{"markdown", "items"}}
result, err := client.Parsing.Get(ctx, job.ID, getParams)
if err != nil {
  log.Fatal(err)
}
for result.Job.Status != "COMPLETED" && result.Job.Status != "FAILED" && result.Job.Status != "CANCELLED" {
  time.Sleep(2 * time.Second)
  result, err = client.Parsing.Get(ctx, job.ID, getParams)
  if err != nil {
    log.Fatal(err)
  }
}
if result.Job.Status != "COMPLETED" {
  log.Fatalf("parse ended as %s", result.Job.Status)
}

// Per-page markdown for the LLM (or use markdown_full for a single string)
var pages []string
for _, page := range result.Markdown.Pages {
  if page.Success {
    pages = append(pages, page.Markdown)
  }
}
llmInput := strings.Join(pages, "\n\n")
_ = llmInput // feed to your LLM

// Walk the items tree for tables
for _, page := range result.Items.Pages {
  if !page.Success {
    continue
  }
  for _, item := range page.Items {
    if item.Type == "table" {
      fmt.Printf("Table on page %d: %d rows\n", page.PageNumber, len(item.Rows))
    }
  }
}

Java

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

// expand is a query parameter — request markdown and items when you fetch the result
ParsingGetParams getParams = ParsingGetParams.builder()
        .jobId(job.id())
        .addExpand("markdown")
        .addExpand("items")
        .build();

ParsingGetResponse result = client.parsing().get(getParams);
while (!result.job().status().equals(ParsingGetResponse.Job.Status.COMPLETED)
        && !result.job().status().equals(ParsingGetResponse.Job.Status.FAILED)
        && !result.job().status().equals(ParsingGetResponse.Job.Status.CANCELLED)) {
    Thread.sleep(2000);
    result = client.parsing().get(getParams);
}
if (!result.job().status().equals(ParsingGetResponse.Job.Status.COMPLETED)) {
    throw new RuntimeException("parse ended as " + result.job().status());
}

// Per-page markdown for the LLM (or use markdown_full for a single string)
StringBuilder llmInput = new StringBuilder();
for (ParsingGetResponse.Markdown.Page page : result.markdown().get().pages()) {
    if (!page.isMarkdownResult()) {
        continue;
    }
    if (llmInput.length() > 0) {
        llmInput.append("\n\n");
    }
    llmInput.append(page.asMarkdownResult().markdown());
}

// Walk the items tree for tables
for (ParsingGetResponse.Items.Page page : result.items().get().pages()) {
    if (!page.isStructuredResult()) {
        continue;
    }
    ParsingGetResponse.Items.Page.StructuredResultPage structured = page.asStructuredResult();
    for (ParsingGetResponse.Items.Page.StructuredResultPage.Item item : structured.items()) {
        if (item.isTable()) {
            System.out.printf("Table on page %d: %d rows%n",
                    structured.pageNumber(), item.asTable().rows().size());
        }
    }
}

CLI

JOB_ID=$(llp parsing create \
  --file-id "$FILE_ID" \
  --tier agentic \
  --version latest \
  | jq -r '.id')

# Poll until the job reaches a terminal status
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

# expand is a query parameter — request markdown and items when you fetch the result
RESULT=$(llp parsing get --job-id "$JOB_ID" --expand markdown --expand items)

# Per-page markdown for the LLM (or use markdown_full for a single string)
echo "$RESULT" | jq -r '[.markdown.pages[] | select(.success) | .markdown] | join("\n\n")'

# Walk the items tree for tables
echo "$RESULT" | jq -r '
  .items.pages[]
  | select(.success)
  | .page_number as $page
  | .items[]
  | select(.type == "table")
  | "Table on page \($page): \(.rows | length) rows"'

Full markdown plus presigned image URLs

For multimodal pipelines that want one markdown blob and the page screenshots as separate downloadable images.

Python

result = client.parsing.parse(
    file_id=file.id,
    tier="agentic_plus",
    version="latest",
    output_options={"images_to_save": ["screenshot"]},
    expand=["markdown_full", "images_content_metadata"],
)

# One big markdown blob for the LLM
print(result.markdown_full)

# Each page screenshot as a downloadable URL
for image in result.images_content_metadata.images:
    print(f"{image.filename}: {image.presigned_url}")

TypeScript

const result = await client.parsing.parse({
  file_id: file.id,
  tier: "agentic_plus",
  version: "latest",
  output_options: { images_to_save: ["screenshot"] },
  expand: ["markdown_full", "images_content_metadata"],
});

console.log(result.markdown_full);

for (const image of result.images_content_metadata?.images ?? []) {
  console.log(`${image.filename}: ${image.presigned_url}`);
}

Go

job, err := client.Parsing.New(ctx, llamacloud.ParsingNewParams{
  FileID:  llamacloud.String(file.ID),
  Tier:    llamacloud.ParsingNewParamsTierAgenticPlus,
  Version: llamacloud.ParsingNewParamsVersionLatest,
  OutputOptions: llamacloud.ParsingNewParamsOutputOptions{
    ImagesToSave: []string{"screenshot"},
  },
})
if err != nil {
  log.Fatal(err)
}

// Request the full markdown blob and the per-image download URLs on the result
getParams := llamacloud.ParsingGetParams{Expand: []string{"markdown_full", "images_content_metadata"}}
result, err := client.Parsing.Get(ctx, job.ID, getParams)
if err != nil {
  log.Fatal(err)
}
for result.Job.Status != "COMPLETED" && result.Job.Status != "FAILED" && result.Job.Status != "CANCELLED" {
  time.Sleep(2 * time.Second)
  result, err = client.Parsing.Get(ctx, job.ID, getParams)
  if err != nil {
    log.Fatal(err)
  }
}

// One big markdown blob for the LLM
fmt.Println(result.MarkdownFull)

// Each page screenshot as a downloadable URL
for _, image := range result.ImagesContentMetadata.Images {
  fmt.Printf("%s: %s\n", image.Filename, image.PresignedURL)
}

Java

ParsingCreateResponse job = client.parsing().create(ParsingCreateParams.builder()
        .fileId(file.id())
        .tier(ParsingCreateParams.Tier.AGENTIC_PLUS)
        .version(ParsingCreateParams.Version.LATEST)
        .outputOptions(ParsingCreateParams.OutputOptions.builder()
                .addImagesToSave(ParsingCreateParams.OutputOptions.ImagesToSave.SCREENSHOT)
                .build())
        .build());

// Request the full markdown blob and the per-image download URLs on the result
ParsingGetParams getParams = ParsingGetParams.builder()
        .jobId(job.id())
        .addExpand("markdown_full")
        .addExpand("images_content_metadata")
        .build();

ParsingGetResponse result = client.parsing().get(getParams);
while (!result.job().status().equals(ParsingGetResponse.Job.Status.COMPLETED)
        && !result.job().status().equals(ParsingGetResponse.Job.Status.FAILED)
        && !result.job().status().equals(ParsingGetResponse.Job.Status.CANCELLED)) {
    Thread.sleep(2000);
    result = client.parsing().get(getParams);
}

// One big markdown blob for the LLM
System.out.println(result.markdownFull().orElse(""));

// Each page screenshot as a downloadable URL
for (ParsingGetResponse.ImagesContentMetadata.Image image : result.imagesContentMetadata().get().images()) {
    System.out.println(image.filename() + ": " + image.presignedUrl().orElse(""));
}

CLI

JOB_ID=$(llp parsing create \
  --file-id "$FILE_ID" \
  --tier agentic_plus \
  --version latest \
  --output-options.images-to-save '[screenshot]' \
  | jq -r '.id')

# Poll until the job reaches a terminal status
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

RESULT=$(llp parsing get --job-id "$JOB_ID" \
  --expand markdown_full \
  --expand images_content_metadata)

# One big markdown blob for the LLM
echo "$RESULT" | jq -r '.markdown_full'

# Each page screenshot as a downloadable URL
echo "$RESULT" | jq -r '.images_content_metadata.images[] | "\(.filename): \(.presigned_url)"'

Join representations by page

Every per-page representation carries page_number, so you can line up markdown, items and metadata for the same page. Build a lookup keyed by page number rather than zipping arrays, since a failed page is still present in each array but has no content.

Python

result = client.parsing.get(
    job_id="JOB_ID", expand=["markdown", "items", "metadata"]
)

confidence = {m.page_number: m.confidence for m in result.metadata.pages}
items_by_page = {p.page_number: p.items for p in result.items.pages if p.success}

for page in result.markdown.pages:
    if not page.success:
        print(f"page {page.page_number} failed: {page.error}")
        continue
    n_items = len(items_by_page.get(page.page_number, []))
    print(page.page_number, confidence.get(page.page_number), n_items, "items")

TypeScript

const result = await client.parsing.get("JOB_ID", {
  expand: ["markdown", "items", "metadata"],
});

const confidence = new Map(
  (result.metadata?.pages ?? []).map((m) => [m.page_number, m.confidence]),
);
const itemsByPage = new Map(
  (result.items?.pages ?? []).flatMap((p) => (p.success ? [[p.page_number, p.items] as const] : [])),
);

for (const page of result.markdown?.pages ?? []) {
  if (!page.success) {
    console.log(`page ${page.page_number} failed: ${page.error}`);
    continue;
  }
  const nItems = itemsByPage.get(page.page_number)?.length ?? 0;
  console.log(page.page_number, confidence.get(page.page_number), nItems, "items");
}

Retrieving results after the job runs

You don’t have to ask for everything you might ever need at parse time. Run a Parse job with one set of expand values, then call get later with a different set, without re-running the job.

This is the right pattern when:

• You don’t know yet what you need. Run with expand=["markdown"], decide later you also want the items tree, fetch with expand=["items"] against the same job ID. Cheaper than re-parsing.
• You’re working with large files. Use expand=["markdown_content_metadata"] first to check size_bytes and decide whether to download.
• You’re resuming work on a previously parsed job. Pass the old job ID and an expand list to retrieve any representation the job produced.

Python

from llama_cloud import LlamaCloud

client = LlamaCloud()  # reads LLAMA_CLOUD_API_KEY from the environment

# Step 1: parse with a minimal expand
result = client.parsing.parse(
    upload_file="doc.pdf",
    tier="cost_effective",
    version="latest",
    expand=["markdown_full"],
)
print(result.job.status)
print(result.markdown_full)

# Step 2: later, retrieve the text representation of the same job
text_result = client.parsing.get(
    job_id=result.job.id,
    expand=["text_full"],
)
print(text_result.text_full)

TypeScript

import fs from "fs";
import { LlamaCloud } from "@llamaindex/llama-cloud";

const client = new LlamaCloud(); // reads LLAMA_CLOUD_API_KEY from the environment

// Step 1: parse with a minimal expand
const result = await client.parsing.parse({
  upload_file: fs.createReadStream("doc.pdf"),
  tier: "cost_effective",
  version: "latest",
  expand: ["markdown_full"],
});
console.log(result.job.status);
console.log(result.markdown_full);

// Step 2: later, retrieve the text representation of the same job
const textResult = await client.parsing.get(result.job.id, { expand: ["text_full"] });
console.log(textResult.text_full);

Go

client := llamacloud.NewClient()

// Step 1: upload and parse with a minimal expand
f, err := os.Open("doc.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.ParsingNewParamsTierCostEffective,
  Version: llamacloud.ParsingNewParamsVersionLatest,
})
if err != nil {
  log.Fatal(err)
}

// expand is a GET parameter — request markdown_full when you poll for the result
getParams := llamacloud.ParsingGetParams{Expand: []string{"markdown_full"}}
result, err := client.Parsing.Get(ctx, job.ID, getParams)
if err != nil {
  log.Fatal(err)
}
for result.Job.Status != "COMPLETED" && result.Job.Status != "FAILED" && result.Job.Status != "CANCELLED" {
  time.Sleep(2 * time.Second)
  result, err = client.Parsing.Get(ctx, job.ID, getParams)
  if err != nil {
    log.Fatal(err)
  }
}
fmt.Println(result.Job.Status)
fmt.Println(result.MarkdownFull)

// Step 2: later, retrieve the text representation of the same job
textResult, err := client.Parsing.Get(ctx, job.ID, llamacloud.ParsingGetParams{
  Expand: []string{"text_full"},
})
if err != nil {
  log.Fatal(err)
}
fmt.Println(textResult.TextFull)

Java

LlamaCloudClient client = LlamaCloudOkHttpClient.fromEnv();

// Step 1: upload and parse with a minimal expand
FileCreateResponse file = client.files().create(FileCreateParams.builder()
        .file(Paths.get("doc.pdf"))
        .purpose("parse")
        .build());

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

// expand is a query parameter — request markdown_full when you poll for the result
ParsingGetParams markdownParams = ParsingGetParams.builder()
        .jobId(job.id())
        .addExpand("markdown_full")
        .build();

ParsingGetResponse result = client.parsing().get(markdownParams);
while (!result.job().status().equals(ParsingGetResponse.Job.Status.COMPLETED)
        && !result.job().status().equals(ParsingGetResponse.Job.Status.FAILED)
        && !result.job().status().equals(ParsingGetResponse.Job.Status.CANCELLED)) {
    Thread.sleep(2000);
    result = client.parsing().get(markdownParams);
}
System.out.println(result.job().status());
System.out.println(result.markdownFull().orElse(""));

// Step 2: later, retrieve the text representation of the same job
ParsingGetResponse textResult = client.parsing().get(ParsingGetParams.builder()
        .jobId(job.id())
        .addExpand("text_full")
        .build());
System.out.println(textResult.textFull().orElse(""));

CLI

# Step 1: upload and parse with a minimal expand
FILE_ID=$(llp files create --file doc.pdf --purpose parse | jq -r '.id')

JOB_ID=$(llp parsing create \
  --file-id "$FILE_ID" \
  --tier cost_effective \
  --version latest \
  | jq -r '.id')

# Poll until the job reaches a terminal status
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

# expand is a query parameter — request markdown_full when you fetch the result
llp parsing get --job-id "$JOB_ID" --expand markdown_full | jq -r '.markdown_full'

# Step 2: later, retrieve the text representation of the same job
llp parsing get --job-id "$JOB_ID" --expand text_full | jq -r '.text_full'

Fetch specific images

images_content_metadata returns every saved image. To fetch a subset, pass their file names in image_filenames; the names come from an earlier full listing or from image items in the items tree. The REST parameter is a single comma-separated string.

Python

result = client.parsing.get(
    job_id="JOB_ID",
    expand=["images_content_metadata"],
    image_filenames="image_0.png,image_5.jpg",
)
for image in result.images_content_metadata.images:
    print(f"{image.filename}: {image.presigned_url}")

TypeScript

const result = await client.parsing.get("JOB_ID", {
  expand: ["images_content_metadata"],
  image_filenames: "image_0.png,image_5.jpg",
});
for (const image of result.images_content_metadata?.images ?? []) {
  console.log(`${image.filename}: ${image.presigned_url}`);
}

Go

result, err := client.Parsing.Get(ctx, "JOB_ID", llamacloud.ParsingGetParams{
  Expand:         []string{"images_content_metadata"},
  ImageFilenames: llamacloud.String("image_0.png,image_5.jpg"),
})
if err != nil {
  log.Fatal(err)
}
for _, image := range result.ImagesContentMetadata.Images {
  fmt.Printf("%s: %s\n", image.Filename, image.PresignedURL)
}

Java

ParsingGetResponse result = client.parsing().get(ParsingGetParams.builder()
        .jobId("JOB_ID")
        .addExpand("images_content_metadata")
        .imageFilenames("image_0.png,image_5.jpg")
        .build());

for (ParsingGetResponse.ImagesContentMetadata.Image image : result.imagesContentMetadata().get().images()) {
    System.out.println(image.filename() + ": " + image.presignedUrl().orElse(""));
}

CLI

llp parsing get --job-id "JOB_ID" \
  --expand images_content_metadata \
  --image-filenames "image_0.png,image_5.jpg" \
  | jq -r '.images_content_metadata.images[] | "\(.filename): \(.presigned_url)"'

Credits billed for a job

expand=usage returns the credits billed for a Parse job, under job.usage rather than at the top level. Combine it with content values: expand=markdown,usage returns both.

Python

result = client.parsing.get(job_id="JOB_ID", expand=["usage"])

print(result.job.usage.credits)

TypeScript

const result = await client.parsing.get("JOB_ID", { expand: ["usage"] });

console.log(result.job.usage?.credits);

CLI

llp parsing get --job-id "JOB_ID" --expand usage | jq '.job.usage.credits'

{
  "job": {
    "id": "JOB_ID",
    "status": "COMPLETED",
    "usage": {
      "credits": 30.0
    }
  }
}

Note

Billing can trail job completion by a short time. credits: null means not recorded yet; fetch again rather than reading it as zero.

Limitations

Fast tier

The current fast version returns markdown and items like every other tier. Only a fast job pinned to a version older than 2026-06-15 is text-only: expand=markdown on such a job is rejected with 400 and a message of the form "Markdown expansion is not available for FAST tier jobs on version ...", and items comes back null. Pin version: "latest" or the current fast version to avoid it.

The fast tier runs no form pass. Requesting processing_options.forms: "enrich" on a fast-tier job returns a validation error, so forms and forms_content_metadata exist only on jobs at cost_effective or higher. See Tiers for the full list of what each tier produces.

Presigned URL expiration

Presigned URLs expire after a limited time. Download files promptly after retrieving them, or call get again with the same expand to get fresh URLs.

See also

• Response format — every field each expand value returns, item types, bounding-box conventions
• Tiers — what each tier produces
• Configuring Parse — expand is a top-level key, not nested in output_options
• Output Options — what you can ask Parse to generate, which then becomes available via expand: image assets, tables as spreadsheet, printed page numbers
• Billing and Usage — plan credits and organization-wide usage, alongside the per-job credits expand=usage returns