Batch PDF Generation at Scale with Blink PDF REST API

import asyncio
import aiohttp
import time
from pathlib import Path

BLINK_API_KEY = "bp_xxxxxxxxxxxxxxxxxxxx"
BLINK_URL = "https://api.blinkpdf.io/v1/render"

# Set this to the recommended concurrency for your plan:
# Free=1, Pro=10, Business=40
MAX_CONCURRENCY = 10  # Pro plan example


async def render_pdf(
    session: aiohttp.ClientSession,
    semaphore: asyncio.Semaphore,
    document: dict,
    retries: int = 4,
) -> tuple[str, bytes | None]:
    """
    Render a single PDF with exponential backoff on 429 / 5xx errors.
    Returns (document_id, pdf_bytes) or (document_id, None) on failure.
    """
    async with semaphore:
        delay = 1.0  # initial backoff in seconds
        for attempt in range(retries):
            try:
                async with session.post(
                    BLINK_URL,
                    headers={
                        "x-api-key": BLINK_API_KEY,
                        "Accept": "application/pdf",
                        "Content-Type": "application/json",
                    },
                    json={
                        "markdown": document["markdown"],
                        "metadata": {"title": document["title"]},
                    },
                ) as response:
                    if response.status == 200:
                        pdf_bytes = await response.read()
                        request_id = response.headers.get("X-Request-Id", "?")
                        print(
                            f"  ✓ {document['id']} rendered (request {request_id})"
                        )
                        return document["id"], pdf_bytes

                    elif response.status == 429:
                        # Rate limited — back off and retry
                        print(
                            f"  ⚠ {document['id']} rate limited, "
                            f"retrying in {delay:.1f}s (attempt {attempt + 1}/{retries})"
                        )
                        await asyncio.sleep(delay)
                        delay *= 2  # exponential backoff

                    else:
                        body = await response.text()
                        print(
                            f"  ✗ {document['id']} failed with "
                            f"{response.status}: {body[:120]}"
                        )
                        return document["id"], None

            except aiohttp.ClientError as exc:
                print(f"  ✗ {document['id']} network error: {exc}")
                await asyncio.sleep(delay)
                delay *= 2

        print(f"  ✗ {document['id']} exhausted retries")
        return document["id"], None


async def batch_render(documents: list[dict], output_dir: str = "output") -> dict:
    """
    Render all documents concurrently and save PDFs to output_dir.
    Returns a summary dict with success/failure counts.
    """
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    semaphore = asyncio.Semaphore(MAX_CONCURRENCY)

    connector = aiohttp.TCPConnector(limit=MAX_CONCURRENCY)
    async with aiohttp.ClientSession(connector=connector) as session:
        tasks = [
            render_pdf(session, semaphore, doc) for doc in documents
        ]

        start = time.monotonic()
        results = await asyncio.gather(*tasks)
        elapsed = time.monotonic() - start

    success, failure = 0, 0
    for doc_id, pdf_bytes in results:
        if pdf_bytes is not None:
            out_path = Path(output_dir) / f"{doc_id}.pdf"
            out_path.write_bytes(pdf_bytes)
            success += 1
        else:
            failure += 1

    print(
        f"\nBatch complete: {success} succeeded, {failure} failed "
        f"in {elapsed:.1f}s ({len(documents) / elapsed:.1f} PDFs/sec)"
    )
    return {"success": success, "failure": failure, "elapsed_s": elapsed}


# Example: build a list of 100 documents
documents = [
    {
        "id": f"report_{i:04d}",
        "title": f"Monthly Report — Account {i:04d}",
        "markdown": f"# Monthly Report\n\n**Account:** {i:04d}\n\nContent for account {i}.",
    }
    for i in range(1, 101)
]

asyncio.run(batch_render(documents, output_dir="reports"))

import { writeFileSync, mkdirSync } from "fs";
import { join } from "path";

const BLINK_API_KEY = "bp_xxxxxxxxxxxxxxxxxxxx";
const BLINK_URL = "https://api.blinkpdf.io/v1/render";
const MAX_CONCURRENCY = 10; // Adjust for your plan
const OUTPUT_DIR = "reports";

mkdirSync(OUTPUT_DIR, { recursive: true });

async function renderWithRetry(document, retries = 4) {
  let delay = 1000; // ms

  for (let attempt = 0; attempt < retries; attempt++) {
    const response = await fetch(BLINK_URL, {
      method: "POST",
      headers: {
        "x-api-key": BLINK_API_KEY,
        Accept: "application/pdf",
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        markdown: document.markdown,
        metadata: { title: document.title },
      }),
    });

    if (response.ok) {
      const buffer = Buffer.from(await response.arrayBuffer());
      console.log(
        `  ✓ ${document.id} rendered (request ${response.headers.get("X-Request-Id")})`
      );
      return { id: document.id, buffer };
    }

    if (response.status === 429) {
      console.log(
        `  ⚠ ${document.id} rate limited, retrying in ${delay}ms (attempt ${attempt + 1}/${retries})`
      );
      await new Promise((r) => setTimeout(r, delay));
      delay *= 2; // exponential backoff
      continue;
    }

    const text = await response.text();
    console.error(`  ✗ ${document.id} failed: ${response.status} ${text.slice(0, 120)}`);
    return { id: document.id, buffer: null };
  }

  console.error(`  ✗ ${document.id} exhausted retries`);
  return { id: document.id, buffer: null };
}

async function runPool(documents, concurrency) {
  const results = [];
  const queue = [...documents];
  const inFlight = new Set();

  await new Promise((resolve) => {
    function startNext() {
      while (inFlight.size < concurrency && queue.length > 0) {
        const doc = queue.shift();
        const promise = renderWithRetry(doc).then((result) => {
          inFlight.delete(promise);
          results.push(result);
          if (queue.length === 0 && inFlight.size === 0) resolve();
          else startNext();
        });
        inFlight.add(promise);
      }
    }
    startNext();
  });

  return results;
}

// Build example documents
const documents = Array.from({ length: 100 }, (_, i) => ({
  id: `report_${String(i + 1).padStart(4, "0")}`,
  title: `Monthly Report — Account ${String(i + 1).padStart(4, "0")}`,
  markdown: `# Monthly Report\n\n**Account:** ${String(i + 1).padStart(4, "0")}\n\nContent for account ${i + 1}.`,
}));

console.log(`Rendering ${documents.length} PDFs with concurrency=${MAX_CONCURRENCY}...`);
const start = Date.now();

const results = await runPool(documents, MAX_CONCURRENCY);

let success = 0;
let failure = 0;
for (const { id, buffer } of results) {
  if (buffer) {
    writeFileSync(join(OUTPUT_DIR, `${id}.pdf`), buffer);
    success++;
  } else {
    failure++;
  }
}

const elapsed = ((Date.now() - start) / 1000).toFixed(1);
console.log(
  `\nBatch complete: ${success} succeeded, ${failure} failed in ${elapsed}s ` +
    `(${(documents.length / elapsed).toFixed(1)} PDFs/sec)`
);

Required rate (PDFs/min) = batch_size / acceptable_duration_minutes

Required rate = 10,000 / 30 ≈ 334 PDFs/min