Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.blinkpdf.io/llms.txt

Use this file to discover all available pages before exploring further.

Blink PDF takes standard Markdown as input and produces a polished, print-ready PDF as output — no templating language, no HTML wrangling, no CSS stylesheets. You write the content; the engine handles the layout.

​
Supported Markdown syntax

Blink PDF implements the full CommonMark specification. Every element you’d expect from a modern Markdown editor is supported out of the box:
ElementSyntax example
Headings# H1 through ###### H6
Bold**bold**
Italic*italic*
Unordered lists- item
Ordered lists1. item
TablesGFM pipe tables
Links[label](https://example.com)
Images![alt](https://example.com/img.png)
Code blocksFenced ``` with language tag
Inline code`code`
Blockquotes> quote
Horizontal rules---
Remote images are fetched at render time, which adds network latency on top of the ~100ms baseline. For the fastest renders, host images on a low-latency CDN or use base64-encoded data URIs.

​
Why you don’t need HTML, CSS, or LaTeX

Traditional PDF generation pipelines require you to write an HTML template, style it with CSS, and then pass it through a headless browser — all before the PDF even starts rendering. LaTeX-based tools add a compile step with its own syntax and error surface. Blink PDF removes all of that. The rendering engine understands Markdown semantics directly, so headings become bookmarks, bold text stays bold, and tables are typeset consistently — without a single line of CSS.
If you’re migrating from an HTML-to-PDF pipeline, you can often replace your entire template with a Markdown string that’s a fraction of the size.

​
How the rendering pipeline works

The pipeline is deliberately simple and deterministic:
  1. You send a POST /v1/render request with a markdown field in the JSON body.
  2. The engine parses your Markdown into a structured document tree.
  3. Layout and typesetting are applied — fonts are subset, Unicode is mapped, accessibility tags are injected.
  4. A PDF binary is streamed back in the response.
The same Markdown input always produces the same PDF output. There are no random seeds, no browser quirks, and no render-pass variability.

​
Example request

Here is a minimal Markdown document and the JSON body you’d send to render it: 
# Invoice #1042

**Date:** 2025-06-01  
**Due:** 2025-06-30

| Description        | Amount  |
|--------------------|---------|
| API Platform (mo.) | $49.00  |
| Overage (2k reqs)  | $4.00   |
| **Total**          | **$53.00** |

> Payment terms: net 30. Thank you for your business.

```
Reference: INV-1042
```

POST https://api.blinkpdf.io/v1/render
Content-Type: application/json
Authorization: Bearer sk_live_...

{
  "markdown": "# Invoice #1042\n\n**Date:** 2025-06-01  \n**Due:** 2025-06-30\n\n| Description | Amount |\n|---|---|\n| API Platform (mo.) | $49.00 |\n| Overage (2k reqs) | $4.00 |\n| **Total** | **$53.00** |\n\n> Payment terms: net 30. Thank you for your business.",
  "metadata": {
    "title": "Invoice #1042",
    "author": "Acme Corp"
  }
}
The response is an application/pdf binary you can stream directly to your user or save to object storage.

​
Tables and code blocks

Tables are fully supported using the GitHub Flavored Markdown (GFM) pipe syntax. Column alignment (:---, :---:, ---:) is respected in the rendered PDF. Blink PDF does not impose row or column limits, but very wide tables will be proportionally scaled to fit the page width. Code blocks are rendered in a monospace typeface with syntax-aware styling. Adding a language identifier after the opening fence (e.g., ```python) enables language labeling in the output — useful for technical documentation and runbooks.

​
The custom engine vs. Chromium

Many PDF services spin up a headless Chromium instance, load a webpage, and screenshot it to PDF. That approach has real costs: cold start times measured in seconds, high memory usage per render, and layout behavior tied to browser internals you don’t control. Blink PDF’s engine renders Markdown natively, without a browser:
Blink PDFChromium-based
Median render time~100ms1–5 s
Cold start0 s2–10 s
Throughput (single node)~30 PDFs/sec2–5 PDFs/sec
Input formatMarkdownHTML + CSS
Layout determinism✅⚠️ browser-dependent
The ~100ms median render time holds even for 100-page documents, because the engine processes the document tree in memory without spawning any subprocess or browser context.

Zero Retention

Learn how Blink PDF processes your Markdown in memory and never stores it.

Accessibility

Every PDF is PDF/UA-1 compliant with full Unicode and emoji support.