Generating PDF documents from LaTeX in Python is one of the most reliable ways to create professional reports, academic papers, invoices, certificates, and technical documents. LaTeX is widely respected for its typography, math rendering, layout control, and consistency across platforms. Python, on the other hand, is excellent for automation, data processing, and building workflows around document generation. When you combine the two, you get a powerful system that can turn raw data, templates, and dynamic content into polished PDFs with very little manual effort.
This guide explains how to create PDF files from LaTeX inside Python, step by step. It covers the most common approaches, from calling a local LaTeX engine like pdflatex or xelatex, to using Python libraries such as pylatex, to generating LaTeX code dynamically from strings or templates. You will also learn how to handle errors, manage file paths, include images, write tables, insert equations, and build reusable document pipelines. The goal is not just to show a tiny snippet, but to give you a complete working understanding of how LaTeX to PDF conversion works in real Python projects.
LaTeX is not like a simple text-to-PDF library. It is a full document preparation system. That means the output quality is usually excellent, but it also means that the environment matters. You need a working TeX distribution installed on the machine where Python runs. You also need to think about compilation commands, auxiliary files, encoding, package dependencies, and escaping special characters. Once those parts are understood, the process becomes very stable and easy to automate.
Why use LaTeX with Python?
There are many ways to generate PDF files in Python, but LaTeX has a special place when quality matters. It is ideal when you need precise layout, mathematical formulas, bibliography support, automatic table of contents, cross references, or a consistent look across many documents. Python adds automation on top of that. For example, Python can fetch data from a database, generate charts, build tables, calculate statistics, and then inject all of that into a LaTeX template before compiling to PDF.
This combination is especially useful in real-world scenarios. A company might use Python to generate monthly financial reports from SQL data. A teacher might generate exams or worksheets with random values. A researcher might generate papers with dynamic tables and figures. A freelancer might create invoices and proposals automatically. A developer might build a web application that exports a nicely formatted PDF. In all of these cases, LaTeX gives the final document a professional finish that is hard to match with plain HTML or basic PDF libraries.
Another advantage is reproducibility. If your Python script and LaTeX template remain the same, you can regenerate the same document later with the same formatting. That makes LaTeX valuable in scientific and legal environments where consistency matters.
The basic workflow
The workflow is simple in concept:
Write or generate LaTeX source code.
Save it to a
.texfile.Call a LaTeX compiler such as
pdflatexorxelatexfrom Python.Collect the generated PDF output.
Handle logs, warnings, and errors if compilation fails.
In practice, there are two main styles. The first style is to write the .tex file yourself, often using a template system or Python string formatting. The second style is to use a Python package like pylatex, which helps you construct the LaTeX document programmatically. Both methods are valid. The best choice depends on how much control you want and how complex the project is.
Installing the required tools
Before you can generate PDFs, your system needs a LaTeX distribution. On Linux, that might be TeX Live. On Windows, it is often MiKTeX or TeX Live. On macOS, many people use MacTeX. Python itself is not enough, because Python is only used to create and launch the LaTeX build process.
You may also want pylatex if you prefer a Python-first interface.
pip install pylatex
If you plan to work with images or charts, you will usually also need libraries such as matplotlib, pandas, or Pillow. These are not required for LaTeX itself, but they are often part of a document automation pipeline.
Method 1: Generate LaTeX and compile it with subprocess
This is the most direct and flexible method. Python writes the LaTeX source to a file, then runs the compiler. This approach is ideal when you want full control and do not want to depend on a wrapper library.
Here is a simple example that generates a PDF from a LaTeX string.
import os
import subprocess
from pathlib import Path
import tempfile
def latex_to_pdf(latex_source: str, output_name: str = "document") -> Path:
"""
Compile LaTeX source into a PDF file and return the PDF path.
Requires pdflatex to be installed and available in PATH.
"""
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = Path(temp_dir)
tex_file = temp_path / f"{output_name}.tex"
tex_file.write_text(latex_source, encoding="utf-8")
command = [
"pdflatex",
"-interaction=nonstopmode",
"-halt-on-error",
tex_file.name,
]
result = subprocess.run(
command,
cwd=temp_path,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
if result.returncode != 0:
raise RuntimeError(
f"LaTeX compilation failed.\n\nSTDOUT:\n{result.stdout}\n\nSTDERR:\n{result.stderr}"
)
pdf_file = temp_path / f"{output_name}.pdf"
final_pdf = Path.cwd() / f"{output_name}.pdf"
final_pdf.write_bytes(pdf_file.read_bytes())
return final_pdf
latex_doc = r"""
\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\begin{document}
\section*{Hello from Python}
This PDF was created by generating LaTeX from Python and compiling it with pdflatex.
\end{document}
"""
pdf_path = latex_to_pdf(latex_doc, "hello_from_python")
print(f"PDF created at: {pdf_path}")
This example uses a temporary directory so that the auxiliary files do not clutter your project. The .tex file is written, pdflatex compiles it, and the final PDF is copied to the current directory. For real projects, this pattern is often a very good baseline.
A useful detail here is the compiler flags. -interaction=nonstopmode prevents LaTeX from stopping for input when there is an error, and -halt-on-error makes it fail fast. This is helpful in automated scripts because you do not want the process to hang waiting for manual input.
Understanding LaTeX source structure
A LaTeX document has two major parts: the preamble and the body. The preamble defines packages, fonts, page size, and document settings. The body contains the actual content. A standard minimal document looks like this:
\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\begin{document}
Your content goes here.
\end{document}
In Python, you can create this as a raw triple-quoted string. Raw strings are often convenient because LaTeX uses many backslashes. However, raw strings do not solve every problem. You still need to think about dynamic content, especially if it includes characters like %, $, &, #, _, {, and }. These characters have special meaning in LaTeX, so they must be escaped before injection.
Escaping special characters
This is one of the most important parts of generating LaTeX from Python. If you insert arbitrary text directly into LaTeX, it may break compilation. For example, a user name like John & Sons will fail because & is a tabular alignment character in LaTeX. A string like 50% completed will fail because % starts a comment. A file name or product code with underscores may also cause problems.
A safe helper function can escape these characters for plain text content.
def escape_latex(text: str) -> str:
replacements = {
"\\": r"\textbackslash{}",
"&": r"\&",
"%": r"\%",
"$": r"\$",
"#": r"\#",
"_": r"\_",
"{": r"\{",
"}": r"\}",
"~": r"\textasciitilde{}",
"^": r"\textasciicircum{}",
}
for old, new in replacements.items():
text = text.replace(old, new)
return text
Here is how you might use it:
name = "John & Sons_2026"
safe_name = escape_latex(name)
latex_doc = rf"""
\documentclass{{article}}
\begin{{document}}
Customer: {safe_name}
\end{{document}}
"""
If your document includes code snippets or LaTeX fragments intentionally, do not escape them blindly. Escape only user-entered plain text, not LaTeX markup itself.
Method 2: Use pylatex for programmatic document creation
The pylatex library makes it easier to build LaTeX documents with Python objects rather than raw strings. This can be very helpful when your document has many sections, tables, loops, or conditional blocks. It gives you a more structured way to compose the document and reduces the chance of formatting mistakes.
Here is a basic example.
from pylatex import Document, Section, Subsection, Command
from pylatex.utils import NoEscape
doc = Document()
doc.preamble.append(Command("title", "Python Generated LaTeX PDF"))
doc.preamble.append(Command("author", "Hassan Agmir"))
doc.preamble.append(Command("date", NoEscape(r"\today")))
doc.append(NoEscape(r"\maketitle"))
with doc.create(Section("Introduction")):
doc.append("This PDF was generated using pylatex.")
with doc.create(Subsection("Why use it?")):
doc.append("It helps build structured LaTeX documents in Python.")
doc.generate_pdf("pylatex_example", clean_tex=False)
With pylatex, you can create sections, tables, lists, and mathematical expressions using Python constructs. It is especially useful for documents generated from data, because you can loop through records and add content dynamically.
For instance, if you were building a report from a list of items:
from pylatex import Document, Section
from pylatex.utils import escape_latex
items = [
"Revenue increased by 12%",
"Costs dropped by 8%",
"User base reached 150,000",
]
doc = Document()
with doc.create(Section("Monthly Summary")):
for item in items:
doc.append(f"{escape_latex(item)}\n\n")
doc.generate_pdf("monthly_summary", clean_tex=False)
This kind of pattern is very common in automated reporting systems.
Generating tables in LaTeX from Python
Tables are one of the best reasons to use LaTeX. They can look clean and consistent, especially when compared with simple HTML-to-PDF pipelines. Python can easily generate table rows from data sources like CSV files, JSON, or databases.
Here is a simple table example using raw LaTeX.
rows = [
("Product A", 120, 9.99),
("Product B", 85, 14.50),
("Product C", 42, 24.00),
]
table_rows = "\n".join(
f"{escape_latex(name)} & {qty} & {price:.2f} \\\\"
for name, qty, price in rows
)
latex_doc = rf"""
\documentclass{{article}}
\usepackage[margin=1in]{{geometry}}
\usepackage{{booktabs}}
\begin{{document}}
\section*{{Sales Table}}
\begin{{tabular}}{{lrr}}
\toprule
Product & Quantity & Price \\
\midrule
{table_rows}
\bottomrule
\end{{tabular}}
\end{{document}}
"""
For more sophisticated formatting, you can use packages like booktabs, array, longtable, or tabularx. These help with professional-looking tables, page wrapping, and multi-page outputs. When the table is large, longtable is especially useful because it can continue across pages.
A more complete table generator might accept a list of dictionaries and build column headers automatically:
def build_latex_table(headers, data):
header_line = " & ".join(escape_latex(str(h)) for h in headers) + r" \\"
body_lines = []
for row in data:
body_lines.append(" & ".join(escape_latex(str(cell)) for cell in row) + r" \\")
body = "\n".join(body_lines)
return rf"""
\begin{{tabular}}{{{'l' * len(headers)}}}
{header_line}
\hline
{body}
\end{{tabular}}
"""
This is not a full production-grade table formatter, but it shows the core idea clearly.
Adding images and charts
Python and LaTeX work beautifully together when images are involved. Python can generate a chart with matplotlib, save it as a PNG or PDF, and then LaTeX can include it in the final document. This is one of the most practical document automation use cases.
First, create a chart in Python:
import matplotlib.pyplot as plt
months = ["Jan", "Feb", "Mar", "Apr", "May"]
sales = [12, 18, 15, 22, 30]
plt.figure(figsize=(6, 4))
plt.plot(months, sales, marker="o")
plt.title("Monthly Sales")
plt.xlabel("Month")
plt.ylabel("Sales")
plt.tight_layout()
plt.savefig("sales_chart.png")
plt.close()
Then include it in LaTeX:
latex_doc = r"""
\documentclass{article}
\usepackage{graphicx}
\usepackage[margin=1in]{geometry}
\begin{document}
\section*{Sales Report}
\includegraphics[width=0.8\textwidth]{sales_chart.png}
\end{document}
"""
When compiling, make sure the image file is in the same working directory as the .tex file, or use a correct path. For vector graphics, PDF images often look sharper than PNG files, especially when printing.
A useful habit is to generate the chart as part of the same Python pipeline before compiling the PDF. That keeps the document fully reproducible. The report is no longer dependent on manually created assets, which is a huge advantage in data-driven workflows.
Working with mathematical expressions
One of LaTeX’s greatest strengths is mathematical typesetting. If your Python-generated document includes formulas, equations, or symbolic notation, LaTeX handles them gracefully. This is one of the main reasons it remains so popular in academic and engineering contexts.
For example:
latex_doc = r"""
\documentclass{article}
\usepackage{amsmath}
\begin{document}
\section*{Equation Example}
The quadratic formula is:
\[
x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}
\]
\end{document}
"""
You can also generate formulas dynamically. Suppose Python calculates statistics and you want to show a formula with actual values:
mean = 12.4
std_dev = 3.8
latex_doc = rf"""
\documentclass{{article}}
\usepackage{{amsmath}}
\begin{{document}}
\section*{{Statistics}}
The mean value is ${mean}$ and the standard deviation is ${std_dev}$.
\[
z = \frac{{x - {mean}}}{{{std_dev}}}
\]
\end{{document}}
"""
In this case, be careful with formatting floating-point numbers. You may want to round them to a fixed precision so the final PDF looks professional.
Using templates for large documents
For larger documents, raw f-strings can become messy. A better approach is to use a templating engine such as Jinja2. The idea is simple: keep your LaTeX structure in a template file, then fill in variables from Python. This keeps your code cleaner and easier to maintain.
Example template file report.tex.j2:
\documentclass{article}
\usepackage[margin=1in]{geometry}
\begin{document}
\section*{Monthly Report}
Client: {{ client_name }}
Revenue: {{ revenue }}
{% for item in notes %}
\subsection*{Note}
{{ item }}
{% endfor %}
\end{document}
Python code to render it:
from jinja2 import Environment, FileSystemLoader
from pathlib import Path
import subprocess
def compile_latex_template(template_dir, template_name, context, output_name="report"):
env = Environment(loader=FileSystemLoader(template_dir))
template = env.get_template(template_name)
rendered = template.render(**context)
tex_path = Path(f"{output_name}.tex")
tex_path.write_text(rendered, encoding="utf-8")
subprocess.run(
["pdflatex", "-interaction=nonstopmode", "-halt-on-error", tex_path.name],
check=True
)
return Path(f"{output_name}.pdf")
This pattern works especially well in web applications and batch reporting jobs. The template stays readable, and the Python code only provides data. It is easier to debug, easier to reuse, and easier to extend.
Handling compilation errors
LaTeX compilation errors can be frustrating at first because a small mistake in one part of the document can produce a confusing log message. The good news is that once you learn the common causes, debugging becomes much easier.
Typical issues include:
Unescaped special characters like
%,_,&, and$Missing packages
Broken braces
{}or mismatched environment tagsInvalid file paths
Missing image files
Unsupported Unicode characters with certain compilers
A robust Python function should always capture the compiler output and show it when something goes wrong. Here is a safer version of the earlier helper:
def compile_latex(tex_path: Path, compiler: str = "pdflatex") -> Path:
command = [
compiler,
"-interaction=nonstopmode",
"-halt-on-error",
tex_path.name,
]
result = subprocess.run(
command,
cwd=tex_path.parent,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
if result.returncode != 0:
log_file = tex_path.with_suffix(".log")
log_content = log_file.read_text(encoding="utf-8", errors="ignore") if log_file.exists() else ""
raise RuntimeError(
f"LaTeX compilation failed.\n\nSTDOUT:\n{result.stdout}\n\nSTDERR:\n{result.stderr}\n\nLOG:\n{log_content}"
)
return tex_path.with_suffix(".pdf")
This kind of logging is extremely valuable because the .log file often contains the real clue. Sometimes the error message shown in Python is not enough by itself.
Choosing between pdflatex, xelatex, and lualatex
The compiler you choose depends on your needs. pdflatex is the most common and widely supported. It works well for many standard documents and is often enough for English text and common package setups. xelatex is useful when you need better Unicode and font handling, especially for non-Latin scripts or system fonts. lualatex is another modern option with powerful Unicode support and Lua integration.
A simple rule is:
Use
pdflatexfor standard documents and maximum compatibility.Use
xelatexwhen you need modern font support or complex Unicode text.Use
lualatexwhen you need advanced typographic flexibility.
Here is how you would switch compilers in Python:
subprocess.run(
["xelatex", "-interaction=nonstopmode", "-halt-on-error", "document.tex"],
check=True
)
When your content includes Arabic, Chinese, Hindi, or other scripts, xelatex is often the better choice. But the exact setup depends on the fonts installed on the machine.
Building a reusable report generator
A practical example makes the workflow easier to understand. Imagine you want to generate a PDF report from Python data every day. The report contains a title, a summary paragraph, a table of values, and a chart. The process can look like this:
Fetch data from a database or API.
Clean and format the values.
Create any charts as image files.
Fill a LaTeX template with the text, table rows, and file names.
Compile the result into a PDF.
Here is a simplified example:
from pathlib import Path
import subprocess
import matplotlib.pyplot as plt
def generate_chart(chart_path: str):
months = ["Jan", "Feb", "Mar", "Apr"]
values = [10, 14, 18, 25]
plt.figure(figsize=(6, 4))
plt.bar(months, values)
plt.title("Performance")
plt.tight_layout()
plt.savefig(chart_path)
plt.close()
def generate_report():
chart_file = "performance.png"
generate_chart(chart_file)
rows = [
("Task A", 12, "Done"),
("Task B", 8, "In progress"),
("Task C", 15, "Done"),
]
table_rows = "\n".join(
f"{escape_latex(name)} & {hours} & {escape_latex(status)} \\\\"
for name, hours, status in rows
)
latex_doc = rf"""
\documentclass{{article}}
\usepackage{{graphicx}}
\usepackage{{booktabs}}
\usepackage[margin=1in]{{geometry}}
\begin{{document}}
\section*{{Daily Report}}
This report was generated automatically using Python and LaTeX.
\subsection*{{Summary Table}}
\begin{{tabular}}{{lrl}}
\toprule
Task & Hours & Status \\
\midrule
{table_rows}
\bottomrule
\end{{tabular}}
\subsection*{{Chart}}
\includegraphics[width=0.9\textwidth]{{{chart_file}}}
\end{{document}}
"""
tex_path = Path("daily_report.tex")
tex_path.write_text(latex_doc, encoding="utf-8")
subprocess.run(
["pdflatex", "-interaction=nonstopmode", "-halt-on-error", tex_path.name],
check=True
)
return tex_path.with_suffix(".pdf")
This example is small, but it reflects how many real systems work. The important thing is that each part is automated and reproducible.
Using LaTeX in web applications
You can also use LaTeX generation in a Flask, Django, or FastAPI app. A user submits data through a form, Python prepares the LaTeX source, compiles it, and returns the PDF as a download. This is useful for invoice generators, course certificate systems, contracts, and custom report services.
The main thing to remember in a web context is security and isolation. Never let unchecked user input directly become executable shell commands. Always write data safely, escape LaTeX special characters, and use fixed compiler commands. Also consider running the compilation in a temporary directory so each request stays isolated from the others.
A very simple Flask-style flow might look like this:
from flask import Flask, send_file, request
from pathlib import Path
import subprocess
import tempfile
app = Flask(__name__)
@app.route("/generate-pdf", methods=["POST"])
def generate_pdf():
name = request.form.get("name", "Guest")
safe_name = escape_latex(name)
latex_doc = rf"""
\documentclass{{article}}
\begin{{document}}
Hello, {safe_name}!
\end{{document}}
"""
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = Path(temp_dir)
tex_file = temp_path / "output.tex"
tex_file.write_text(latex_doc, encoding="utf-8")
subprocess.run(
["pdflatex", "-interaction=nonstopmode", "-halt-on-error", tex_file.name],
cwd=temp_path,
check=True
)
pdf_file = temp_path / "output.pdf"
return send_file(pdf_file, as_attachment=True, download_name="document.pdf")
This is not production-ready by itself, but it shows the overall structure. A production system would usually need better validation, queueing, timeout handling, and logging.
Common best practices
A good LaTeX-to-PDF pipeline in Python should follow a few habits. Keep the template separate from the logic whenever possible. Escape all user input that is treated as text. Use temporary directories to keep generated files organized. Capture compiler output so debugging is possible. Prefer reproducible chart generation and deterministic data formatting. Keep your LaTeX preamble stable and small unless you truly need more packages.
It also helps to create helper functions for repeated tasks. For example, a function for formatting dates, a function for escaping text, a function for building tables, and a function for compiling the document. This reduces duplication and makes your code easier to maintain over time.
Another useful practice is to test documents with simple content first. Before inserting complex tables or charts, make sure the basic compilation flow works. Then add features one by one. This makes it much easier to isolate problems when they appear.
Troubleshooting Unicode and fonts
Unicode issues are common when people first move from plain text to LaTeX. If you use pdflatex, some Unicode characters may not work out of the box. In many cases, switching to xelatex or lualatex is the easiest solution. Those compilers handle modern fonts and Unicode text much more naturally.
For example:
subprocess.run(
["xelatex", "-interaction=nonstopmode", "-halt-on-error", "document.tex"],
check=True
)
If you need Arabic or other right-to-left scripts, the configuration becomes more advanced. You may need special packages, font selection, and compiler settings. The exact setup depends on the language, the font support available, and the kind of output you want. In many multilingual documents, xelatex is the better starting point.
A polished example with sections, table, and chart
Here is a more complete example that combines several concepts into one PDF generation script.
from pathlib import Path
import subprocess
import matplotlib.pyplot as plt
def escape_latex(text: str) -> str:
replacements = {
"\\": r"\textbackslash{}",
"&": r"\&",
"%": r"\%",
"$": r"\$",
"#": r"\#",
"_": r"\_",
"{": r"\{",
"}": r"\}",
"~": r"\textasciitilde{}",
"^": r"\textasciicircum{}",
}
for old, new in replacements.items():
text = text.replace(old, new)
return text
def create_chart(path: str):
labels = ["A", "B", "C", "D"]
values = [5, 11, 8, 14]
plt.figure(figsize=(6, 4))
plt.plot(labels, values, marker="o")
plt.title("Sample Trend")
plt.xlabel("Category")
plt.ylabel("Value")
plt.tight_layout()
plt.savefig(path)
plt.close()
def build_pdf():
chart_path = "trend_chart.png"
create_chart(chart_path)
data = [
("Alpha", 12, "Excellent"),
("Beta", 9, "Good"),
("Gamma", 6, "Needs review"),
]
rows = "\n".join(
f"{escape_latex(name)} & {score} & {escape_latex(status)} \\\\"
for name, score, status in data
)
latex_source = rf"""
\documentclass{{article}}
\usepackage[margin=1in]{{geometry}}
\usepackage{{graphicx}}
\usepackage{{booktabs}}
\usepackage{{array}}
\begin{{document}}
\begin{{center}}
{{\LARGE Sample Automated Report}}\\[1em]
Generated by Python and LaTeX
\end{{center}}
\section*{{Overview}}
This document demonstrates a complete LaTeX to PDF workflow in Python.
\section*{{Results}}
\begin{{tabular}}{{lrl}}
\toprule
Item & Score & Status \\
\midrule
{rows}
\bottomrule
\end{{tabular}}
\section*{{Trend Chart}}
\includegraphics[width=0.9\textwidth]{{{chart_path}}}
\end{{document}}
"""
tex_file = Path("sample_report.tex")
tex_file.write_text(latex_source, encoding="utf-8")
subprocess.run(
["pdflatex", "-interaction=nonstopmode", "-halt-on-error", tex_file.name],
check=True
)
return tex_file.with_suffix(".pdf")
pdf_file = build_pdf()
print(f"Generated PDF: {pdf_file}")
This script generates a chart, constructs a LaTeX report, compiles it, and outputs a PDF. It is a strong foundation for automation projects because it combines text, tables, and visuals in one repeatable process.
When LaTeX is the right choice
LaTeX is not always the best answer for every PDF task. If you only need a very simple receipt or a quick one-page layout, HTML-to-PDF tools or direct PDF libraries may be easier. But when the document needs high-quality typesetting, mathematical notation, academic formatting, or complex tables, LaTeX is often the better tool.
It is also a great choice when your output must scale. Once your template is stable, Python can generate hundreds or thousands of PDFs with the same structure. That makes it ideal for batch reporting, certificate generation, educational materials, publishing workflows, and scientific documentation.
Final thoughts
Using LaTeX to create PDFs in Python gives you a powerful blend of automation and typesetting quality. Python handles data, logic, and workflow. LaTeX handles the visual output with precision and elegance. Together they form a reliable system for generating professional documents automatically.
The most important things to remember are simple: install a LaTeX distribution, escape special characters, compile in a temporary folder when possible, and capture errors carefully. Once those basics are in place, the rest becomes a matter of design. You can generate anything from a one-page letter to a multi-section report with tables, charts, formulas, and references.
For developers, researchers, teachers, and business teams, this is one of the cleanest ways to produce high-quality PDFs from Python. It may take a little setup at first, but the result is a workflow that is stable, reusable, and powerful enough for serious document automation.
Hassan Agmir
Author · Filenewer
Writing about file tools and automation at Filenewer.
Try It Free
Process your files right now
No account needed · Fast & secure · 100% free
Browse All Tools
