polyscrape API · Parse

Parse

Upload a document and get clean, LLM-ready Markdown back.

Send a document as multipart form-data (field name `file`) and get clean Markdown back. Handles PDF, Word, PowerPoint, Excel, Outlook, EPUB, CSV, and XML, up to 25 MB per upload. Priced by output: $0.001 per started 1,000 words of returned Markdown, a minimum of $0.001 and a maximum of $0.10 — documents beyond 100,000 words are truncated and the response `truncated` flag is set to true. A document that yields no extractable text returns 422 and is never charged. This endpoint is stateless: nothing is stored. Use it when you already have the file bytes; use scrape for a document URL.

POST /api/v1/parse $0.001 per 1,000 words

Get API Key Open Playground

Use your polyscrape API key instantly, or inspect the sample response first.

curl

curl -X POST https://polyscrape.com/api/v1/parse \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $POLYSCRAPE_API_KEY" \
  -d '{"file": "\u003cbinary document, multipart/form-data\u003e"}'

Sample response

{
  "filename": "report.pdf",
  "markdown": "# Q3 Report\n\nRevenue grew 12% quarter over quarter...",
  "title": "Q3 Report",
  "truncated": false,
  "word_count": 842
}

API Playground

Run a real /api/v1/parse request. No key? We show the real sample result so you can still inspect the shape.

Endpoint

POST /api/v1/parse

sample mode

Auth header X-API-Key

Cost $0.001 per 1,000 words

API key

Leave empty to inspect the response shape without spending API balance.

Multipart file upload

This endpoint takes a document as multipart form-data (field file), so it isn't runnable from the browser playground. Use the copy-paste code examples below, or send it from your own client. The sample response shape is shown on the right.

Response

POST /api/v1/parse

sample

{
  "filename": "report.pdf",
  "markdown": "# Q3 Report\n\nRevenue grew 12% quarter over quarter...",
  "title": "Q3 Report",
  "truncated": false,
  "word_count": 842
}

Request and response

The full contract for /api/v1/parse: what to send and what comes back.

Request body

file file (multipart) required

The document to convert, sent as multipart form-data. Up to 25 MB.

Response fields

Field	Type	Description
`filename`	string	The uploaded filename, echoed back.
`title`	string \| null	First Markdown heading when available, else null.
`markdown`	string	Clean Markdown extracted from the document.
`word_count`	integer	Word count of the returned Markdown — the basis for the charge (1 credit per started 1,000 words).
`truncated`	boolean	True when the document exceeded 100,000 words and the returned Markdown was cut to that cap.

Code examples

Copy, paste, swap in your API key.

curl -X POST https://polyscrape.com/api/v1/parse \
  -H "X-API-Key: " \
  -F "[email protected]"

import requests

with open("report.pdf", "rb") as f:
    resp = requests.post(
        "https://polyscrape.com/api/v1/parse",
        headers={"X-API-Key": ""},
        files={"file": f},
    )
print(resp.json())

import fs from "node:fs";

const form = new FormData();
form.append("file", new Blob([fs.readFileSync("report.pdf")]), "report.pdf");

const resp = await fetch("https://polyscrape.com/api/v1/parse", {
  method: "POST",
  headers: { "X-API-Key": "" },
  body: form,
});
console.log(await resp.json());

What developers build with it

Common ways Parse ends up in production.

Converting a user-uploaded PDF or Office file to Markdown for an LLM.

Extracting document text inside an ingestion or RAG pipeline.

Normalizing mixed document formats to a single Markdown shape.

Status codes

The same predictable contract on every endpoint.

`200`	Success. The lookup completed and was charged, even if the response is empty (a no-match search, or a thin page).
`400`	The request was rejected before any fetch (for search: an unsupported country code). Never charged.
`401`	Missing or unknown API key. Never charged.
`402`	Not enough balance on the account. Never charged. The detail is a JSON object with error, message, credits_required, and api_credits.
`422`	Invalid request body (wrong shape or types). The detail is a list of per-field errors. Never charged.
`429`	Rate limit exceeded: max 10 requests per second per API key (5/second for parse, which is CPU-heavier). Never charged.
`502`	Upstream fetch failed — the target page or search could not be fetched (site down, unreachable, timed out, or blocked). Never charged.
`Body`	Every error response is JSON shaped as {"detail": ...}. detail is a message string, except 402 (a JSON object) and 422 (a list of field errors).

Other endpoints

Explore the rest of the polyscrape API.

Scrape

/api/v1/scrape

/api/v1/search

Account Balance

/api/v1/account/balance

View all endpoints

Pay once. Spend when needed.

New accounts start with a free API balance. Paid balance never expires, so it can sit until your workflows need it.

Free

$0.50 to start

$0.50 free balance to start. Get an API key in seconds with no credit card.

Scrape, Search, and Parse
No credit card required
Perfect for a first integration

Create free account

Starter

$10 one-time

Adds $10 to your API balance for steady production traffic and early automated jobs.

Balance never expires
From $0.001 per call
Useful for small pipelines

Get started

Pro Most popular

$100 one-time

$130 spendable balance, including a $30 bonus. The sweet spot for production workloads.

$100 + $30 free balance
Best value per workload
Built for automated pipelines

Get started

FAQ

Questions before you connect?

Pricing & Balance

Usage-based, charged against your prepaid balance. Scrape and parse cost $0.001 per 1,000 words of Markdown returned (minimum $0.001, capped at $0.10). Search costs $0.001 for the search plus $0.002 per result returned. Same prices across REST and MCP — no quota math, no tiers.

The whole scraping stack, handled for you: a residential proxy, a real Chrome browser fingerprint, HTML-to-Markdown conversion, built-in document parsing (PDF, Word, PowerPoint, Excel, Outlook, EPUB, CSV, XML), and caching. You send a URL, a search, or a document and get back clean, LLM-ready Markdown.

No. Your API balance never expires, so you can use it whenever your workflows need it. In the unlikely event polyscrape is ever discontinued, unused paid balance is refunded.

Paid API requests stop with a 402 until you add more balance. This keeps spend predictable and prevents unexpected charges.

API & Integration

Create and manage API keys from your account, then send your key in the X-API-Key header from your app, scripts, or internal tools.

Yes. Your dashboard shows every request, its cost, and your remaining balance, so you can track spend while building and running automated workflows.

Yes, a completed request is billable even when the answer is empty (for example a page with no readable content). Errors like 402 or 429 are never charged.

We enforce a rate limit of 10 requests per second per API key. If you exceed it, the API returns HTTP 429. Build exponential backoff (briefly pausing before retrying) into your application code.

Our support team responds to email inquiries within 1 business day. We can help with account, billing, and API integration questions.

Give your product and agents clean Markdown.

Start with a free key and $0.50 free balance, on REST, MCP, or both.

Start with $0.50 free