Automating PDF Reports with Python

Install the requests library

pip install requests

Store your API key securely

Never hardcode API keys in your scripts. Use an environment variable instead. Generate your API key from the Pretty PDF dashboard under Settings, then export it in your shell:

# Linux / macOS
export PRETTYPDF_API_KEY="your-api-key-here"

# Windows (PowerShell)
$env:PRETTYPDF_API_KEY = "your-api-key-here"

Basic configuration

Create a Python file with the base configuration that every script in this tutorial will use:

import os
import requests

API_KEY = os.environ["PRETTYPDF_API_KEY"]
API_BASE = "https://api.prettypdfprinter.com/v1"

HEADERS = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json",
}

If the PRETTYPDF_API_KEY environment variable is not set, the script will raise a KeyError immediately rather than failing silently later. This is intentional — you want to know right away if the key is missing.

Process multiple URLs

When you have a list of URLs to convert, iterate through them sequentially with a delay between requests to respect rate limits. The function below reads URLs from a list, generates a filename from each URL, and tracks progress:

import os
import re
import time
import requests

API_KEY = os.environ["PRETTYPDF_API_KEY"]
API_BASE = "https://api.prettypdfprinter.com/v1"
HEADERS = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json",
}

DELAY_BETWEEN_REQUESTS = 3  # seconds (safe for Pro+)


def url_to_filename(url):
    """Convert a URL to a safe filename."""
    name = url.split("//")[-1]
    name = re.sub(r"[^\w\-.]", "_", name)
    return name[:100] + ".pdf"


def batch_convert(urls, output_dir="pdfs", template="clean"):
    """Convert a list of URLs to PDFs with rate limiting."""
    os.makedirs(output_dir, exist_ok=True)
    results = {"success": [], "failed": []}

    for i, url in enumerate(urls, 1):
        print(f"[{i}/{len(urls)}] Processing: {url}")

        try:
            # Generate PDF
            response = requests.post(
                f"{API_BASE}/generate/url",
                headers=HEADERS,
                json={"url": url, "template": template},
            )
            response.raise_for_status()
            result = response.json()

            # Download PDF
            doc_id = result["id"]
            pdf_response = requests.get(
                f"{API_BASE}/files/{doc_id}",
                headers=HEADERS,
            )
            pdf_response.raise_for_status()

            # Save to disk
            filename = url_to_filename(url)
            filepath = os.path.join(output_dir, filename)
            with open(filepath, "wb") as f:
                f.write(pdf_response.content)

            print(f"  Saved: {filepath}")
            results["success"].append(url)

        except requests.RequestException as e:
            print(f"  Failed: {e}")
            results["failed"].append({"url": url, "error": str(e)})

        # Rate limit delay (skip after last URL)
        if i < len(urls):
            time.sleep(DELAY_BETWEEN_REQUESTS)

    print(f"\nDone: {len(results['success'])} succeeded, "
          f"{len(results['failed'])} failed")
    return results


# Usage
urls = [
    "https://docs.python.org/3/tutorial/index.html",
    "https://docs.python.org/3/library/os.html",
    "https://docs.python.org/3/library/pathlib.html",
    "https://docs.python.org/3/library/json.html",
]
batch_convert(urls, output_dir="python-docs")

Reading URLs from a file

For larger batches, keep your URLs in a text file (one per line) and read them in:

def load_urls(filepath):
    """Load URLs from a text file, one URL per line."""
    with open(filepath) as f:
        return [line.strip() for line in f if line.strip()]

urls = load_urls("urls.txt")
batch_convert(urls)

Self-contained script for cron

A cron job runs in a minimal environment, so the script should be self-contained with absolute paths and logging to a file:

#!/usr/bin/env python3
"""Weekly documentation archival script.
Run via cron: 0 6 * * 1 /usr/bin/python3 /home/user/scripts/archive_docs.py
"""
import os
import sys
import time
import logging
from datetime import datetime

import requests

# Configuration
API_KEY = os.environ.get("PRETTYPDF_API_KEY")
if not API_KEY:
    sys.exit("PRETTYPDF_API_KEY environment variable not set")

API_BASE = "https://api.prettypdfprinter.com/v1"
HEADERS = {"X-API-Key": API_KEY, "Content-Type": "application/json"}
OUTPUT_DIR = "/home/user/archives/docs"
URL_FILE = "/home/user/scripts/doc_urls.txt"
DELAY = 3

# Logging
date_str = datetime.now().strftime("%Y-%m-%d")
log_file = f"/home/user/logs/archive_{date_str}.log"
os.makedirs(os.path.dirname(log_file), exist_ok=True)
logging.basicConfig(filename=log_file, level=logging.INFO,
                    format="%(asctime)s %(message)s")

def main():
    # Create dated output directory
    out_dir = os.path.join(OUTPUT_DIR, date_str)
    os.makedirs(out_dir, exist_ok=True)

    # Load URLs
    with open(URL_FILE) as f:
        urls = [l.strip() for l in f if l.strip()]

    logging.info(f"Starting archive of {len(urls)} URLs")
    success, failed = 0, 0

    for i, url in enumerate(urls, 1):
        try:
            resp = requests.post(f"{API_BASE}/generate/url",
                                 headers=HEADERS,
                                 json={"url": url, "template": "clean"},
                                 timeout=30)
            resp.raise_for_status()
            doc_id = resp.json()["id"]

            pdf = requests.get(f"{API_BASE}/files/{doc_id}",
                               headers=HEADERS, timeout=30)
            pdf.raise_for_status()

            filename = f"{i:03d}.pdf"
            filepath = os.path.join(out_dir, filename)
            with open(filepath, "wb") as f:
                f.write(pdf.content)

            logging.info(f"OK: {url} -> {filepath}")
            success += 1
        except Exception as e:
            logging.error(f"FAIL: {url} -> {e}")
            failed += 1

        if i < len(urls):
            time.sleep(DELAY)

    logging.info(f"Done: {success} succeeded, {failed} failed")

if __name__ == "__main__":
    main()

Crontab entry

Edit your crontab with crontab -e and add the following line to run the script every Monday at 6:00 AM:

# Archive documentation every Monday at 6 AM
0 6 * * 1 PRETTYPDF_API_KEY="your-key" /usr/bin/python3 /home/user/scripts/archive_docs.py

Windows Task Scheduler

On Windows, create a scheduled task that runs python C:\scripts\archive_docs.py on your preferred schedule. Set the PRETTYPDF_API_KEY environment variable in the task's environment settings or in your system environment variables.