# PDF Text Extractor — Markdown, OCR & Metadata (`memo23/pdf-text-extractor`) Actor

Turn any PDF URL into clean data: full text, LLM-ready Markdown, per-page content, and metadata. Reads scanned PDFs via OCR (23 languages), supports page ranges, and processes files in parallel. Export JSON, CSV, or Excel. Ideal for RAG pipelines, invoices, and research.

- **URL**: https://apify.com/memo23/pdf-text-extractor.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 pdf processeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## PDF Text Extractor — Markdown, OCR & Metadata 📄

Turn any PDF URL into clean, structured data: **full text, LLM-ready Markdown, per-page content, and document metadata** — with an **OCR fallback that reads scanned, image-only PDFs**. No browser, no proxies, no setup. Paste URLs, get JSON, CSV, or Excel.

![How it works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-pdf-text-extractor.png)

### Why use PDF Text Extractor?

- 🧾 **Markdown output built for LLMs and RAG** — headings, paragraphs, and bullet lists are reconstructed from the PDF layout, so you can feed documents straight into embeddings, vector stores, or prompts without cleanup.
- 🔍 **OCR for scanned documents** — pages with no text layer (scans, faxes, image-only invoices) are rendered and OCRed automatically in 23 languages. Only the pages that need it are OCRed, and only those are billed.
- 📑 **Page ranges** — extract just `1-5, 8, 12-` instead of paying to process a 400-page manual you need 3 pages from.
- 🗂️ **Rich metadata** — title, author, subject, keywords, creator, producer, creation and modification dates (normalized to ISO 8601).
- 📎 **Three input modes** — URLs, direct file upload, or base64 (for API calls). The only extractor in the niche that also opens **password-protected PDFs** (`pdfPassword` input).
- 🌐 **Proxy support** — route downloads through Apify Proxy when a host blocks datacenter IPs or geo-restricts files.
- ⚡ **Fast and parallel** — processes up to 20 PDFs concurrently; a typical text PDF takes under a second.
- 💰 **Pay per PDF, not per compute unit** — transparent pay-per-event pricing; failed downloads are never charged.

### What data can you extract?

| Field | Description |
|---|---|
| `text` | Complete plain text of the document (or selected page range) |
| `markdown` | Markdown rendition with reconstructed headings, paragraphs, and lists |
| `pages` | Optional per-page array: page number, text, and whether OCR was used |
| `metadata` | Title, author, subject, keywords, creator, producer, creation/modification dates |
| `pageCount` / `extractedPageCount` | Total pages vs. pages actually extracted |
| `charCount` / `wordCount` | Size of the extracted text |
| `ocr` | Whether OCR ran, how many pages were OCRed, and the language used |
| `status` / `error` | `success` or `failed` with the exact reason (HTTP error, not a PDF, too large, timeout) |

### Use cases

- **RAG pipelines & AI agents** — convert reports, papers, and manuals into Markdown chunks for vector search.
- **Invoice & document processing** — pull text out of supplier invoices, including scanned ones, for downstream parsing.
- **Research & academia** — batch-extract text from arXiv papers, theses, and journal PDFs.
- **Legal & compliance** — make contract archives and court filings searchable.
- **Data pipelines** — feed the dataset into Zapier, Make, LangChain, LlamaIndex, or your own code via the Apify API.

### How to extract text from PDF files

1. Provide PDFs any way you like: paste **direct URLs**, **upload a file** from your computer, or pass **base64 data** via the API.
2. (Optional) Set a **page range**, a **password** for protected files, toggle **Markdown** / **per-page text**, or enable **OCR** for scanned documents.
3. Run the Actor and download results as **JSON, CSV, Excel, or XML** — or fetch them via API.

#### Example input

```json
{
    "urls": [
        "https://arxiv.org/pdf/1706.03762",
        "https://example.com/scanned-invoice.pdf"
    ],
    "pageRange": "1-10",
    "includeMarkdown": true,
    "ocrScannedPages": true,
    "ocrLanguage": "eng"
}
````

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `urls` | array | — | Direct URLs to PDF files; redirects are followed |
| `pdfFile` | file | — | Upload a single PDF directly in Apify Console |
| `base64Pdfs` | array | — | Base64 PDFs: plain strings or `{"filename", "data"}` objects (for API calls) |
| `pdfPassword` | string (secret) | — | Password for opening protected PDFs |
| `pageRange` | string | all pages | e.g. `1-5, 8, 12-` (`12-` = page 12 to the end) |
| `includeFullText` | boolean | `true` | Include complete plain text |
| `includeMarkdown` | boolean | `true` | Include the Markdown rendition |
| `includePerPageText` | boolean | `false` | Include the per-page `pages` array |
| `ocrScannedPages` | boolean | `false` | OCR pages that have no text layer |
| `ocrLanguage` | string | `eng` | OCR language (23 supported, incl. deu, fra, spa, jpn, chi\_sim) |
| `maxConcurrency` | integer | `5` | PDFs processed in parallel (1–20) |
| `timeoutPerPdfSecs` | integer | `90` | Download timeout per PDF |
| `maxPdfSizeMb` | integer | `100` | Larger PDFs are skipped as failed rows |
| `proxyConfiguration` | object | auto | Blocked downloads auto-retry via proxy; set this to force proxy for every download |

At least one of `urls`, `pdfFile`, or `base64Pdfs` is required; all sources are processed together in one run.

### Output example

```json
{
    "url": "https://arxiv.org/pdf/1706.03762",
    "fileName": "1706.03762",
    "status": "success",
    "pageCount": 15,
    "extractedPageCount": 15,
    "metadata": {
        "title": "Attention Is All You Need",
        "author": null,
        "creationDate": "2024-04-10T21:11:43Z",
        "producer": "pdfTeX-1.40.25"
    },
    "text": "Attention Is All You Need. The dominant sequence transduction models...",
    "markdown": "# Attention Is All You Need\n\nThe dominant sequence transduction models...",
    "pages": [{ "page": 1, "text": "...", "ocr": false }],
    "ocr": { "enabled": true, "pagesOcred": 0, "language": "eng" },
    "charCount": 40026,
    "wordCount": 6527,
    "processedAt": "2026-07-11T10:00:00.000Z"
}
```

### Tips for best results

- URLs must point at the **PDF file itself**, not a viewer page around it. If the link opens a browser preview, look for the direct `.pdf` download URL.
- Turn **OCR on only when you expect scanned pages** — it is slower and billed per OCR page. Text-layer pages are never OCRed.
- For very large PDFs, use `pageRange` and disable `includePerPageText` to keep dataset rows small.
- The Markdown structure is **heuristic** (PDFs carry no real semantics): headings are detected from font sizes. It is tuned for reports, papers, and invoices; heavily designed layouts may come out flatter.

### FAQ

**Can it read scanned PDFs?**
Yes — enable `ocrScannedPages`. Pages without a usable text layer are rendered and OCRed (Tesseract engine, 23 languages). Pages that already have text are never OCRed, so mixed documents are handled efficiently.

**Does it handle password-protected PDFs?**
Yes — set the `pdfPassword` input and protected documents are decrypted and processed like any other. Without the password (or with a wrong one), the file is reported as a failed row with a clear message.

**Can I upload local files?**
Yes — use the **Upload a PDF file** field in Apify Console, or pass `base64Pdfs` when calling via API. URLs, uploads, and base64 items can all be mixed in a single run.

**A host keeps rejecting the download (403) — what can I do?**
Usually nothing — blocked downloads (401/403/407/429) are **automatically retried through a proxy**. If a host needs the proxy for every request (e.g. geo-restricted files), set `proxyConfiguration` to force it for all downloads.

**Does it extract tables or images?**
Tables come out as text lines (not structured cells) and images are not extracted. If you need structured table extraction, contact us — see Support below.

**What happens when a URL fails?**
You still get a dataset row with `status: "failed"` and the exact error. Failed PDFs are not charged.

### Use with AI agents via MCP

This Actor works out of the box with AI agents through the [Apify MCP server](https://mcp.apify.com) — let Claude, Cursor, or any MCP-capable agent read PDFs for you.

**Claude Code:**

```bash
claude mcp add apify --transport http https://mcp.apify.com --header "Authorization: Bearer YOUR_APIFY_TOKEN"
```

**Claude Desktop / Cursor / VS Code** — add to your MCP config:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com",
            "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
        }
    }
}
```

**Example prompts:**

> "Extract the text from https://example.com/report.pdf and summarize the key findings."

> "Get pages 1–10 of this PDF as Markdown and list every dollar amount mentioned."

### Support & feedback

Found a bug or missing a feature? Open an issue on the Actor's **Issues tab** in Apify Console — issues are typically answered within 24 hours. For custom extraction logic (structured tables, specific invoice formats, private storage integrations), reach out via the contact form on my profile.

### Explore more scrapers

Check out my other Actors: [apify.com/memo23](https://apify.com/memo23) — 270+ scrapers for jobs, real estate, social media, e-commerce, and lead generation.

### ⚠️ Disclaimer

This Actor processes PDF files that you provide via publicly accessible URLs. You are responsible for ensuring you have the right to download and process those files, and for complying with the terms of service of the sites hosting them, as well as any applicable copyright and data-protection laws. The Actor does not bypass authentication, paywalls, or DRM.

### SEO Keywords

pdf text extractor, extract text from pdf, pdf to text api, pdf to markdown converter, pdf ocr api, scanned pdf to text, pdf parser api, pdf metadata extractor, pdf data extraction, batch pdf text extraction, pdf to json, pdf for rag, llm pdf ingestion, pdf text scraper, convert pdf to markdown online, ocr scanned documents api, password protected pdf text extraction, upload pdf extract text, base64 pdf to text, pdf mcp ai agent

# Actor input Schema

## `urls` (type: `array`):

Direct URLs to PDF files. Each URL must point to a downloadable PDF document (redirects are followed).

## `pdfFile` (type: `string`):

Upload a single PDF file directly from your computer.

## `base64Pdfs` (type: `array`):

Base64-encoded PDFs, each either a plain base64 string (data-URI prefix allowed) or an object <code>{"filename": "doc.pdf", "data": "…"}</code>.

## `pdfPassword` (type: `string`):

Password for opening protected PDFs. Applied to every document in the run that needs one.

## `pageRange` (type: `string`):

Extract only these pages, e.g. <code>1-5, 8, 12-</code> (<code>12-</code> = page 12 to the end). Leave empty to extract all pages. Applies to every PDF in the run.

## `includeFullText` (type: `boolean`):

Include the complete plain text of the document in the <code>text</code> field.

## `includeMarkdown` (type: `boolean`):

Include a Markdown rendition in the <code>markdown</code> field — headings, paragraphs, and bullet lists are reconstructed from the PDF layout. Ideal for feeding LLMs, embeddings, and RAG pipelines.

## `includePerPageText` (type: `boolean`):

Include a <code>pages</code> array with the text of each individual page. Disable to keep output rows small for large PDFs.

## `ocrScannedPages` (type: `boolean`):

When a page has no usable text layer (scanned/image-only PDFs), render it and run OCR to recover the text. Slower and billed per OCR page — only pages that actually need it are OCRed.

## `ocrLanguage` (type: `string`):

Language of the scanned documents, used by the OCR engine.

## `maxConcurrency` (type: `integer`):

How many PDFs to download and process in parallel. Higher is faster but uses more memory.

## `timeoutPerPdfSecs` (type: `integer`):

Maximum time to wait for each PDF download. Raise it for very large files or slow hosts.

## `maxPdfSizeMb` (type: `integer`):

PDFs larger than this are skipped (reported as failed rows) to protect memory.

## `proxyConfiguration` (type: `object`):

Blocked downloads (401/403/407/429) automatically retry through a proxy — no setup needed. Set this only to force EVERY download through the proxy, e.g. for geo-restricted hosts.

## Actor input object example

```json
{
  "urls": [
    "https://arxiv.org/pdf/1706.03762"
  ],
  "includeFullText": true,
  "includeMarkdown": true,
  "includePerPageText": false,
  "ocrScannedPages": false,
  "ocrLanguage": "eng",
  "maxConcurrency": 5,
  "timeoutPerPdfSecs": 90,
  "maxPdfSizeMb": 100
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://arxiv.org/pdf/1706.03762"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/pdf-text-extractor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "urls": ["https://arxiv.org/pdf/1706.03762"] }

# Run the Actor and wait for it to finish
run = client.actor("memo23/pdf-text-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://arxiv.org/pdf/1706.03762"
  ]
}' |
apify call memo23/pdf-text-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=memo23/pdf-text-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PDF Text Extractor — Markdown, OCR & Metadata",
        "description": "Turn any PDF URL into clean data: full text, LLM-ready Markdown, per-page content, and metadata. Reads scanned PDFs via OCR (23 languages), supports page ranges, and processes files in parallel. Export JSON, CSV, or Excel. Ideal for RAG pipelines, invoices, and research.",
        "version": "0.0",
        "x-build-id": "YgKTAK8YWC0brppev"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~pdf-text-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-pdf-text-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/memo23~pdf-text-extractor/runs": {
            "post": {
                "operationId": "runs-sync-memo23-pdf-text-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/memo23~pdf-text-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-pdf-text-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "urls": {
                        "title": "📄 PDF URLs",
                        "type": "array",
                        "description": "Direct URLs to PDF files. Each URL must point to a downloadable PDF document (redirects are followed).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "pdfFile": {
                        "title": "📎 Upload a PDF file",
                        "type": "string",
                        "description": "Upload a single PDF file directly from your computer."
                    },
                    "base64Pdfs": {
                        "title": "🧬 Base64 PDFs (for API calls)",
                        "type": "array",
                        "description": "Base64-encoded PDFs, each either a plain base64 string (data-URI prefix allowed) or an object <code>{\"filename\": \"doc.pdf\", \"data\": \"…\"}</code>."
                    },
                    "pdfPassword": {
                        "title": "🔑 PDF password",
                        "type": "string",
                        "description": "Password for opening protected PDFs. Applied to every document in the run that needs one."
                    },
                    "pageRange": {
                        "title": "📑 Page range",
                        "type": "string",
                        "description": "Extract only these pages, e.g. <code>1-5, 8, 12-</code> (<code>12-</code> = page 12 to the end). Leave empty to extract all pages. Applies to every PDF in the run."
                    },
                    "includeFullText": {
                        "title": "Full text",
                        "type": "boolean",
                        "description": "Include the complete plain text of the document in the <code>text</code> field.",
                        "default": true
                    },
                    "includeMarkdown": {
                        "title": "Markdown (LLM/RAG-ready)",
                        "type": "boolean",
                        "description": "Include a Markdown rendition in the <code>markdown</code> field — headings, paragraphs, and bullet lists are reconstructed from the PDF layout. Ideal for feeding LLMs, embeddings, and RAG pipelines.",
                        "default": true
                    },
                    "includePerPageText": {
                        "title": "Per-page text",
                        "type": "boolean",
                        "description": "Include a <code>pages</code> array with the text of each individual page. Disable to keep output rows small for large PDFs.",
                        "default": false
                    },
                    "ocrScannedPages": {
                        "title": "🔍 OCR scanned pages",
                        "type": "boolean",
                        "description": "When a page has no usable text layer (scanned/image-only PDFs), render it and run OCR to recover the text. Slower and billed per OCR page — only pages that actually need it are OCRed.",
                        "default": false
                    },
                    "ocrLanguage": {
                        "title": "OCR language",
                        "enum": [
                            "eng",
                            "deu",
                            "fra",
                            "spa",
                            "ita",
                            "por",
                            "nld",
                            "pol",
                            "ces",
                            "swe",
                            "dan",
                            "nor",
                            "fin",
                            "tur",
                            "rus",
                            "ukr",
                            "ara",
                            "heb",
                            "hin",
                            "jpn",
                            "kor",
                            "chi_sim",
                            "chi_tra"
                        ],
                        "type": "string",
                        "description": "Language of the scanned documents, used by the OCR engine.",
                        "default": "eng"
                    },
                    "maxConcurrency": {
                        "title": "⚡ Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many PDFs to download and process in parallel. Higher is faster but uses more memory.",
                        "default": 5
                    },
                    "timeoutPerPdfSecs": {
                        "title": "⏱️ Timeout per PDF (seconds)",
                        "minimum": 5,
                        "maximum": 600,
                        "type": "integer",
                        "description": "Maximum time to wait for each PDF download. Raise it for very large files or slow hosts.",
                        "default": 90
                    },
                    "maxPdfSizeMb": {
                        "title": "📦 Max PDF size (MB)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "PDFs larger than this are skipped (reported as failed rows) to protect memory.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy for downloads",
                        "type": "object",
                        "description": "Blocked downloads (401/403/407/429) automatically retry through a proxy — no setup needed. Set this only to force EVERY download through the proxy, e.g. for geo-restricted hosts."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```