Add document generation to your app and never manage PDF infrastructure

Every app eventually needs to produce a document. An invoice after a payment, a report a user downloads, a contract, a statement. It sounds small, so a team builds it in house. Then it becomes a thing you maintain forever: a headless browser in the deploy, a render server to keep alive, print CSS that breaks on the customer with two hundred line items, and a memory leak that pages someone at 2am.

The document was never the hard part. The infrastructure around turning it into a PDF is. kove exists so you never have to own that. It is a hosted document API. We run the rendering. You run nothing.

What “hosted” actually removes

When PDF generation lives in your stack, you carry all of this:

• A headless browser bundled into your container, fattening every deploy.
• A render service to scale, monitor, and restart when it falls over.
• Print CSS for page breaks, repeated table headers, and page numbers.
• Font handling, so a long company name does not shift the whole layout.
• The on-call cost when any of the above breaks under load.

With a hosted API, all of that is on our side. You send a JSON document, you get a finished PDF back. There is no browser in your deploy, no render server in your stack, and nothing to scale. The first version you ship is the version that still works when a customer has a huge order, because the pagination logic lives in the renderer, not in CSS you hand-tuned once and forgot.

The document is just data

kove takes a JSON description of what goes in the PDF. You list the page, an optional header and footer, and a body made of blocks. Each block is one idea:

{
  "page": { "size": "A4" },
  "footer": { "pageNumbers": "Page {page} of {pages}" },
  "body": [
    { "type": "heading", "text": "Invoice F-2026-118" },
    { "type": "fields", "items": [
      { "label": "Bill to", "value": "Globex LLC" },
      { "label": "Due date", "value": "2026-06-30" }
    ] },
    { "type": "table",
      "columns": ["Description", "Qty", "Amount"],
      "rows": [
        ["Consulting", "40", "$4,800.00"],
        ["Hosting", "1", "$84.00"]
      ] },
    { "type": "totals", "lines": [
      { "label": "Total", "value": "$4,884.00" }
    ] }
  ]
}

You already have the customer, the line items, and the totals in your code. Producing this is data work, not layout work. Map your values into the shape and send it to the API with a Bearer key:

curl -X POST https://api.kove.dev/v1/documents \
  -H "Authorization: Bearer $KOVE_API_KEY" \
  -H "Content-Type: application/json" \
  -d @invoice.json \
  -o invoice.pdf

kove repeats the header on every page, keeps rows whole, keeps the totals with the table, and adds the page numbers. You never touch any of that.

Your coding agent does the wiring

Here is the part that makes adding kove feel like nothing at all. You do not have to learn the API and write the integration by hand. kove ships AI-friendly docs: an llms.txt index, an OpenAPI spec, and the simple JSON model above. That is exactly what a coding agent needs to integrate a service correctly.

So you open your agent in your project and ask:

Add PDF invoices to my checkout. After a payment succeeds, generate the invoice with kove and email it to the customer.

The agent finds where payments succeed, reads the spec, writes the call, pulls the data, and reads the key from an environment variable. It hands you a diff. You review it like any pull request and ship. The whole external provider is one documented HTTP call sitting in your own code, which means you can read it, test it, and own it.

Try it without an account

You do not have to sign up to see the output. The CLI runs locally, free and unlimited:

npx kove validate invoice.json
npx kove render invoice.json -o invoice.pdf

Validate first so a typo fails fast, then render and open the PDF. The same JSON goes to the hosted API when you are ready, with no changes. Build locally for free, ship through the API in production.

Pay for output, not for uptime

Running PDF infrastructure has a fixed cost even when nobody is generating documents: the servers, the monitoring, the maintenance, the attention. A hosted API flips that. kove is pay-per-use: free to start, then you pay only for the PDFs you actually make. There is no idle render server to fund and no cluster to right-size.

That is the trade worth making. Document generation is real work, but it is not your product. Let your coding agent add it in an afternoon, let the hosted API carry the rendering, and spend your time on the part of the app only you can build. Start by telling your agent to add document generation. The infrastructure stays our problem.