PDF

Any URL to a print-ready PDF. Same anti-bot engine as the scraper.

POST /v1/scrape/pdf 25 / 35 credits Utilities

Point us at a URL and get back a base64-encoded PDF rendered through a real headless browser. Pick the paper size, portrait or landscape, and the viewport. Hostile sites are cleared by the same anti-bot engine as /v1/scrape/url, so you never run or babysit a browser yourself.

The hard part

A faithful PDF in production means running a headless browser, waiting for the page to actually settle, clearing anti-bot walls, and picking the right paper geometry — then keeping that browser fleet alive. You send a URL and a paper size; we return the bytes.

What it does

Paper sizes: Letter, Legal, Tabloid, Ledger, and A0–A6. `landscape=true` for wide content.
`viewport_width`/`viewport_height` control page layout before pagination.
`cookies` and `headers` render authenticated or gated pages; `session_id` reuses a sticky residential exit IP for multi-step flows.
`wait_extra_ms` waits out late-loading SPA content before capture.
Base64 returned inline (no S3 round-trip, no presigned-URL dance).
Failures and timeouts don't bill.

Send a call

curl -X POST https://scrapenest.dev/v1/scrape/pdf \
  -H "Authorization: Bearer sn_••••" \
  -H "Content-Type: application/json" \
  -d '{ "url": "https://stripe.com/docs/api", "format": "A4" }' \
  | jq -r .pdf_base64 | base64 -d > page.pdf

import base64, httpx

r = httpx.post(
    "https://scrapenest.dev/v1/scrape/pdf",
    headers={"Authorization": "Bearer sn_••••"},
    json={"url": "https://stripe.com/docs/api", "format": "A4"},
    timeout=120,
)
r.raise_for_status()
data = r.json()
with open("page.pdf", "wb") as f:
    f.write(base64.b64decode(data["pdf_base64"]))
print(f"{data['bytes']} bytes, {data['format']}")

import { writeFileSync } from "node:fs";

const r = await fetch("https://scrapenest.dev/v1/scrape/pdf", {
  method: "POST",
  headers: {
    "Authorization": "Bearer sn_••••",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ url: "https://stripe.com/docs/api", format: "A4" }),
});
const data = await r.json();
writeFileSync("page.pdf", Buffer.from(data.pdf_base64, "base64"));

package main

import (
    "bytes"
    "encoding/base64"
    "encoding/json"
    "net/http"
    "os"
)

func main() {
    body, _ := json.Marshal(map[string]any{
        "url":    "https://stripe.com/docs/api",
        "format": "A4",
    })
    req, _ := http.NewRequest("POST",
        "https://scrapenest.dev/v1/scrape/pdf", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer sn_••••")
    req.Header.Set("Content-Type", "application/json")
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    var out struct{ PdfBase64 string `json:"pdf_base64"` }
    json.NewDecoder(resp.Body).Decode(&out)
    pdf, _ := base64.StdEncoding.DecodeString(out.PdfBase64)
    os.WriteFile("page.pdf", pdf, 0644)
}

Request body

{
  "url": "https://stripe.com/docs/api",
  "format": "A4"
}

Response shape

{
  "url": "https://stripe.com/docs/api",
  "final_url": "https://stripe.com/docs/api",
  "status_code": 200,
  "proxy_used": "residential",
  "elapsed_ms": 4120,
  "format": "A4",
  "landscape": false,
  "bytes": 248913,
  "pdf_base64": "JVBERi0xLjcKJ…",
  "cache_hit": false,
  "credits_charged": 25
}

What it costs

25 credits for a standard render; 35 credits for landscape or large paper (Tabloid, Ledger, A0–A2). Cache hits bill at 1 credit. Failures don't bill.

Large or landscape formats (Tabloid, Ledger, A0–A2) bill at 35 credits; standard portrait sizes bill at 25.
The response streams with keepalive and a ~110s hard timeout, so big renders don't hit an edge 502.