Skip to content

Flask / payslips

Payslip PDFs in Flask

Post your payslip HTML to a render API from a route returning send_file, then return send_file with a BytesIO and mimetype="application/pdf". No browser binary in your Flask deployment.

Why payslips become PDFs

A payslip is a personal financial record an employee keeps, uses to apply for credit, and expects to be able to open years later. That is the difference between a document and a view of a database, and it is why HR and payroll teams keep asking for this.

What a payslip has to carry

Before any of the code below matters, the template has to produce a document that is actually a payslip. These are the fields that make it one, and the ones a reader or an auditor will look for first.

  • gross pay, itemised by basic, overtime and any allowances
  • each deduction named separately with its own amount
  • net pay, which is the number the employee checks first
  • year-to-date totals for gross, tax and net
  • the pay period and the payment date, which are not the same day
  • the employee identifier and tax reference

Turning your Jinja2 template into a document

You already have the markup. Render_template("invoice.html", **context) gives you it as a string, which is the only input the render needs. url_for("static", filename=...) produces a path, not a URL. Pass _external=True when the markup is going to be rendered somewhere other than the user's browser, or inline the stylesheet.

The Flask implementation

httpx is the client most projects here already have. The render happens in a route returning send_file, and you return send_file with a BytesIO and mimetype="application/pdf".

python

# app.py
from io import BytesIO

import httpx
from flask import render_template, send_file


@app.get("/payslips/<int:payslip_id>.pdf")
def payslip_pdf(payslip_id):
    payslip = Payslip.query.get_or_404(payslip_id)

    html = render_template("payslip_pdf.html", payslip=payslip)

    upstream = httpx.post(
        "https://api.pdfpipe.xyz/v1/pdf",
        headers={"Authorization": f"Bearer {app.config['PDFPIPE_KEY']}"},
        json={"html": html, "options": {"format": "A4", "printBackground": True}},
        timeout=60.0,
    )
    upstream.raise_for_status()

    return send_file(
        BytesIO(upstream.content),
        mimetype="application/pdf",
        download_name=f"payslip-{payslip_id}.pdf",
    )

The CSS that makes a payslip page correctly

The layout problem specific to this document is that gross, deductions and net must be visible together without scrolling or breaking, on one page, every time. These rules handle it.

css

/* Gross, deductions and net have to be visible together. One page,
   every time, regardless of how many deduction lines there are. */
.payslip { break-inside: avoid; }
.summary { break-inside: avoid; }

@page { size: A4; margin: 15mm; }

What goes wrong in Flask

The development server handles one request at a time by default, so a render that takes two seconds makes the whole app look dead for two seconds. That is a dev-server artefact rather than a real problem, but it is the reason people conclude PDF generation is slow before they have deployed anything.

What people try first

Most Flask projects reach for pdfkit, which is a wrapper around the wkhtmltopdf binary. The binary has to be present on every machine, and its rendering engine is a fork of WebKit that stopped tracking the web around 2016. That works until it is running on more than one machine, at which point the browser becomes the thing you operate rather than the thing you use.

Where the payslip lives afterwards

Rendering is the short part. Payslips are personal financial records the employee will need for credit applications and tax filings for years. Employers commonly retain them for six years, and employees expect to be able to download an old one long after they have left.

Getting the document right

  • Check net pay and the deduction breakdown, which is what an employee checks first and complains about immediately.
  • Generation is triggered by a payroll run, producing every employee's document at once, so size the timeout for that path rather than for a health check.
  • This is a batch shape: render the run through the batch endpoint rather than firing thousands of individual requests.
  • Backgrounds are painted by default here, so a design that uses colour needs nothing set. Only an explicit print_background of false turns them off.

Frequently asked

Do I need Chromium installed to generate payslips from Flask?

No. The render happens over HTTP, so your Flask deployment stays the size it is now. That is the main reason to use an API rather than pdfkit, which is a wrapper around the wkhtmltopdf binary. The binary has to be present on every machine, and its rendering engine is a fork of WebKit that stopped tracking the web around 2016.

How do I stop a long payslip using all the memory?

Return send_file with a BytesIO and mimetype="application/pdf". The development server handles one request at a time by default, so a render that takes two seconds makes the whole app look dead for two seconds. That is a dev-server artefact rather than a real problem, but it is the reason people conclude PDF generation is slow before they have deployed anything.

What has to be on a payslip?

At minimum: gross pay, itemised by basic, overtime and any allowances; each deduction named separately with its own amount; net pay, which is the number the employee checks first. The one to get right before anything else is net pay and the deduction breakdown, which is what an employee checks first and complains about immediately.

Do I need to store the generated payslips?

Depends on the document, and this one has a clear answer: payslips are personal financial records the employee will need for credit applications and tax filings for years. Employers commonly retain them for six years, and employees expect to be able to download an old one long after they have left.

Can I keep my existing payslip template?

Yes, if it produces HTML. Whatever renders your payslip view today can render the same markup for the PDF, which is why the CSS above is the only new thing you write.

Related

Other Flask documents, and the same payslip in other stacks.

Contract PDFs in Flaska contract has to be fixed at signature. Both parties need to be certain they are looking at identical wordsPacking slip PDFs in Flaska packing slip is printed and physically placed in a box. It exists to be paper.Ticket PDFs in Flaska ticket has to work at a gate with no signalInvoice PDFs in Flaskan invoice is a legal record of a demand for paymentReceipt PDFs in Flaska receipt is proof a payment happenedPayslip PDFs in FastAPIUsing httpx, in an async endpoint returning StreamingResponse.Payslip PDFs in LaravelUsing the Http facade, in a controller returning streamDownload.Payslip PDFs in SymfonyUsing HttpClientInterface, in a controller returning StreamedResponse.Payslip PDFs in Ruby on RailsUsing Net::HTTP, in a controller action using send_data.Payslip PDFs in ExpressUsing fetch, in a route handler that pipes the response.The same thing in plain PythonWithout the framework, using httpx directly.When the output is wrongBlank pages, missing backgrounds, breaks in the wrong place, by symptom.All stacks and documentsThe full grid of what this covers.the full Flask guideSetup, error handling and the deployment shape, not just the request.payslip generation in productionVolume, storage and the delivery step, for teams already shipping these.how this compares to weasyprintThe tradeoff written out, including where the incumbent is the better call.deployment shapesServerless, containers and long-running processes, and what each costs you.

100 free documents a month, no card.