How To Install Wkhtmltopdf on Fedora 42

Wkhtmltopdf is a powerful command-line utility that converts HTML pages to PDF documents with remarkable accuracy. Whether you’re a developer creating reports, a system administrator automating documentation, or an end user who needs to archive web content, installing wkhtmltopdf on Fedora 42 opens up efficient HTML-to-PDF conversion capabilities. This comprehensive guide explores multiple installation methods, configuration options, and advanced usage scenarios to help you successfully implement wkhtmltopdf on your Fedora 42 system.

Table of Contents

What is Wkhtmltopdf?

Wkhtmltopdf stands as an open-source command-line shell utility that transforms HTML documents into PDF files or images. The tool utilizes the WebKit rendering engine-the same technology powering browsers like Safari-to generate high-quality PDF conversions that faithfully preserve the original HTML layout, styling, and functionality. Unlike simplistic HTML converters, wkhtmltopdf handles complex web elements including CSS, JavaScript, forms, and multimedia content.

The utility excels in various scenarios, including:

Generating printable reports from web applications
Creating documentation from online resources
Archiving website content in PDF format
Batch processing multiple HTML files into standardized PDFs
Creating invoices, statements, and other business documents

Compared to alternatives like Puppeteer or WeasyPrint, wkhtmltopdf offers a straightforward approach with minimal dependencies while maintaining excellent rendering fidelity. Its cross-platform compatibility makes it particularly valuable for mixed-environment workflows where consistent output is essential.

System Requirements

Before proceeding with installation, ensure your Fedora 42 system meets these baseline requirements:

A 64-bit x86 processor (x86_64 architecture)
Minimum 2GB RAM (4GB recommended for processing complex documents)
At least 100MB free disk space for the application and dependencies
Internet connection for repository-based installation
Root or sudo privileges for system-wide installation

Wkhtmltopdf version 0.12.6-6.fc42 is currently available in the Fedora 42 repositories. This version includes improvements in rendering accuracy and security fixes compared to previous releases. The application can run on minimal server installations but performs optimally on systems with graphical capabilities installed.

Prerequisites and Dependencies

Installing wkhtmltopdf requires several dependencies to ensure proper functionality. Before installation, prepare your system by installing these essential packages:

sudo dnf install xorg-x11-fonts-75dpi xorg-x11-fonts-Type1 libpng libjpeg openssl icu libX11 libXext libXrender

These packages provide necessary components:

X11 font packages ensure proper text rendering in the generated PDFs
Image libraries (libpng, libjpeg) support graphics processing
SSL libraries enable secure connections for fetching remote content
Qt dependencies handle the WebKit rendering process

If you’re upgrading from a previous version, check your existing installation:

which wkhtmltopdf
wkhtmltopdf --version

To remove an existing installation before proceeding with a fresh install:

sudo dnf remove wkhtmltopdf wkhtmltoimage

Proper font configuration is crucial for high-quality output, especially for documents containing non-Latin characters or specialized typography.

Method 1: Installation via DNF Package Manager

The simplest and most reliable method to install wkhtmltopdf on Fedora 42 is through the default package manager, DNF. This approach ensures you receive the version specifically built and tested for your distribution.

First, ensure your system is up-to-date:

sudo dnf update

Next, install wkhtmltopdf directly from the Fedora repositories:

sudo dnf install wkhtmltopdf

The package manager will automatically resolve and install all required dependencies. Fedora 42 repositories currently include wkhtmltopdf version 0.12.6-6.fc42. This version provides a good balance of stability and features for most use cases.

Verify the installation was successful:

wkhtmltopdf --version

You should see output confirming the installed version, similar to:

wkhtmltopdf 0.12.6 (with patched qt)

The DNF installation method offers several advantages:

Automatic dependency resolution
Seamless integration with system updates
Security patches through standard system updates
Verified package authenticity

However, this method may not provide the absolute latest version available from the developers. If you require cutting-edge features, consider the alternative installation methods.

Method 2: Installation from RPM Package

For users who need a specific version or when the repository version isn’t suitable, installing directly from an RPM package offers more control. This method allows installation of the latest releases or specific versions that might not yet be available in the Fedora repositories.

First, download the appropriate RPM package for Fedora from the official GitHub releases page. For a 64-bit system:

wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox-0.12.6.1-2.almalinux9.x86_64.rpm

Note that you might need to adjust the URL based on the latest available version for Fedora 42. Check the wkhtmltopdf GitHub releases page for the most current package.

Install the downloaded RPM package:

sudo dnf install ./wkhtmltox-0.12.6.1-2.almalinux9.x86_64.rpm

If you encounter dependency issues, allow DNF to resolve them:

sudo dnf install --allowerasing .wkhtmltox-0.12.6.1-2.almalinux9.x86_64.rpm

After installation, verify that the binary is accessible:

wkhtmltopdf --version

The RPM installation places the main binary in /usr/bin/wkhtmltopdf and shared libraries in the appropriate system directories. This method provides several benefits:

Access to versions not yet in the official repositories
Ability to install specific versions for compatibility reasons
More control over the installation process

However, manually installed packages won’t automatically update with your system, requiring manual intervention for future updates.

Method 3: Building from Source Code

For maximum customization and access to the very latest features, building wkhtmltopdf from source code offers unparalleled flexibility. This approach is particularly valuable for developers who need specific optimizations or features not available in pre-built packages.

Begin by installing development tools and dependencies:

sudo dnf group install "Development Tools"
sudo dnf install git qt5-qtbase-devel qt5-qtwebkit-devel qt5-qtsvg-devel libXext-devel libXrender-devel openssl-devel fontconfig-devel libpng-devel libjpeg-turbo-devel

Clone the wkhtmltopdf repository from GitHub:

git clone --recursive https://github.com/wkhtmltopdf/wkhtmltopdf.git
cd wkhtmltopdf

Configure the build environment:

mkdir build
cd build
qmake-qt5 ../wkhtmltopdf.pro

Compile the source code:

make -j$(nproc)

This process may take several minutes depending on your system’s capabilities. The -j$(nproc) flag optimizes compilation by utilizing all available CPU cores.

Install the compiled binaries:

sudo make install

By default, this installs wkhtmltopdf to /usr/local/bin/. Verify the installation:

wkhtmltopdf --version

Building from source provides these advantages:

Access to the latest development features
Ability to customize compile-time options
Optimization for specific hardware or use cases
Patching or modifying functionality as needed

This method requires more technical knowledge and time but offers the greatest flexibility for specialized deployments.

Configuring Environment Variables and Paths

Proper environment configuration ensures wkhtmltopdf functions correctly across different user sessions and applications. After installation, verify that the binary is in your system path:

which wkhtmltopdf

If the command returns no results, add the installation directory to your PATH:

echo 'export PATH=$PATH:/usr/local/bin' >> ~/.bashrc
source ~/.bashrc

For system-wide configuration, create a file in /etc/profile.d/:

sudo echo 'export PATH=$PATH:/usr/local/bin' > /etc/profile.d/wkhtmltopdf.sh
sudo chmod +x /etc/profile.d/wkhtmltopdf.sh

If you encounter library loading issues, particularly with libwkhtmltox.so.0, create the necessary symbolic links:

sudo ln -s /usr/local/lib/libwkhtmltox.so.0.12.6 /usr/lib64/libwkhtmltox.so.0

For persistent configuration options, create a configuration file:

mkdir -p ~/.config/wkhtmltopdf
echo "--page-size A4 --margin-top 20mm --margin-bottom 20mm" > ~/.config/wkhtmltopdf/default

These settings will be used automatically when no command-line options are specified, streamlining repetitive conversion tasks.

Font Configuration for Proper Rendering

High-quality PDF generation depends heavily on proper font configuration. Ensure comprehensive font support by installing additional font packages:

sudo dnf install google-noto-sans-fonts google-noto-serif-fonts google-noto-sans-mono-fonts google-noto-cjk-fonts

For multilingual support, add language-specific fonts:

sudo dnf install dejavu-sans-fonts dejavu-serif-fonts dejavu-sans-mono-fonts

Custom fonts can be added to either user-specific or system-wide directories:

# User-specific fonts
mkdir -p ~/.local/share/fonts
cp your-custom-font.ttf ~/.local/share/fonts/
fc-cache -f -v

# System-wide fonts
sudo cp your-custom-font.ttf /usr/share/fonts/
sudo fc-cache -f -v

Test font rendering with a simple HTML document:

echo "Font Test äöüß 你好 こんにちは" > fonttest.html
wkhtmltopdf fonttest.html fonttest.pdf

Properly configured fonts ensure consistent document rendering, especially important for multilingual content or branded materials with specific typography requirements.

Testing Your Installation

After installing wkhtmltopdf, thorough testing helps confirm functionality and identify potential issues. Start with a basic conversion:

echo "

Hello World

This is a test.

" > test.html
wkhtmltopdf test.html test.pdf

Test conversion from a live website:

wkhtmltopdf https://fedoraproject.org fedora-website.pdf

Verify that JavaScript processing works correctly:

echo "<html><body><div id='content'></div><script>document.getElementById('content').innerHTML = 'JavaScript works!';</script></body></html>" > jstest.html
wkhtmltopdf --enable-javascript --javascript-delay 1000 jstest.html jstest.pdf

Check complex layout handling:

wkhtmltopdf --enable-javascript --javascript-delay 2000 https://getbootstrap.com/docs/5.3/examples/grid/ bootstrap-grid.pdf

Performance testing with larger documents helps establish expectations for production use:

time wkhtmltopdf https://en.wikipedia.org/wiki/Fedora_Linux wiki-fedora.pdf

These tests provide confidence in your installation and help identify any potential configuration issues before using wkhtmltopdf in production environments.

Common Issues and Troubleshooting

Despite careful installation, you may encounter issues with wkhtmltopdf. Here are solutions for the most common problems:

Missing Shared Libraries

If you see errors about missing shared libraries:

sudo dnf install libXrender libXext libfontconfig
sudo ldconfig

Blank or Incomplete PDFs

When PDFs appear blank or incomplete, JavaScript execution may be the culprit:

wkhtmltopdf --enable-javascript --javascript-delay 3000 input.html output.pdf

Permission Denied Errors

For permission issues:

sudo chmod +x /usr/bin/wkhtmltopdf
sudo chown root:root /usr/bin/wkhtmltopdf

X11 Display Errors in Headless Environments

On servers without a display:

sudo dnf install xorg-x11-server-Xvfb
xvfb-run -a wkhtmltopdf input.html output.pdf

SSL Errors with HTTPS Sites

To resolve SSL certificate validation issues:

wkhtmltopdf --no-ssl-error-page --ignore-ssl-errors input.html output.pdf

Memory Issues with Large Documents

For large or complex documents:

wkhtmltopdf --lowquality --image-dpi 72 large-document.html output.pdf

Debugging Technique

Use verbose output to identify problems:

wkhtmltopdf --verbose input.html output.pdf

If issues persist, check the wkhtmltopdf GitHub issues page or the Fedora forums for similar problems and solutions. The active community often provides workarounds for edge cases.

Basic Usage Examples

Mastering wkhtmltopdf’s command-line options unlocks its full potential. Here are essential usage examples:

Standard Page Conversion

wkhtmltopdf document.html document.pdf

Web Page to PDF

wkhtmltopdf https://fedoraproject.org fedora.pdf

Custom Page Size and Orientation

wkhtmltopdf --page-size A4 --orientation Landscape document.html landscape-document.pdf

Setting Margins

wkhtmltopdf --margin-top 20 --margin-bottom 20 --margin-left 15 --margin-right 15 document.html document-with-margins.pdf

Adding Headers and Footers

wkhtmltopdf --header-left "[date]" --header-right "[page]/[topage]" --footer-center "Confidential" document.html document-with-headers.pdf

Table of Contents Generation

wkhtmltopdf toc --toc-header-text "Contents" document.html document-with-toc.pdf

Multiple Input Files

wkhtmltopdf cover cover.html toc chapter1.html chapter2.html output.pdf

Image Quality Settings

wkhtmltopdf --image-quality 100 document.html high-quality.pdf

These examples demonstrate wkhtmltopdf’s versatility for various document conversion scenarios. Combining multiple options creates highly customized outputs tailored to specific needs.

Advanced Usage Scenarios

Beyond basic conversions, wkhtmltopdf supports sophisticated document generation workflows:

Batch Processing with Shell Scripting

#!/bin/bash
for file in *.html; do
    wkhtmltopdf "$file" "${file%.html}.pdf"
done

Custom Headers with HTML and CSS

Create a header.html file:

<!DOCTYPE html>
<html>
<head>
  <style>
    .header { font-size: 10pt; color: #808080; }
    .logo { float: right; }
  </style>
</head>
<body>
  <div class="header">
    <span class="logo">Company Logo</span>
    <span>Confidential Document - [date]</span>
  </div>
</body>
</html>

Then use it:

wkhtmltopdf --header-html header.html document.html document-with-fancy-header.pdf

Watermarking

wkhtmltopdf --background --page-width 210mm --page-height 297mm watermark.html --background document.html watermarked-document.pdf

Generating PDF Forms

wkhtmltopdf --enable-forms form.html interactive-form.pdf

API Integration Example (Python)

import subprocess

def html_to_pdf(input_file, output_file, options=None):
    cmd = ['wkhtmltopdf']
    if options:
        cmd.extend(options)
    cmd.extend([input_file, output_file])
    return subprocess.call(cmd)

# Usage
html_to_pdf('report.html', 'report.pdf', ['--enable-javascript', '--javascript-delay', '1000'])

These advanced techniques demonstrate how wkhtmltopdf can be integrated into complex document processing systems, automated workflows, and web applications.

Maintaining and Updating Wkhtmltopdf

Regular maintenance ensures optimal performance and security. To check your current version:

wkhtmltopdf --version

For DNF-installed versions, update alongside system packages:

sudo dnf update wkhtmltopdf

For manually installed RPMs, check for new releases on the official GitHub repository and reinstall using the newer package:

wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.7-1/wkhtmltox-0.12.7-1.fedora42.x86_64.rpm
sudo dnf upgrade ./wkhtmltox-0.12.7-1.fedora42.x86_64.rpm

Source-built installations require recompiling from updated source code:

cd wkhtmltopdf
git pull
cd build
make clean
qmake-qt5 ../wkhtmltopdf.pro
make -j$(nproc)
sudo make install

Before major updates, back up any custom configurations:

cp -r ~/.config/wkhtmltopdf ~/.config/wkhtmltopdf.bak

Monitor the official wkhtmltopdf release notes for security updates, as these should be prioritized to protect systems that process external HTML content.

Integration with Other Tools

Wkhtmltopdf’s versatility enables integration with numerous other applications and workflows:

Content Management Systems

Many CMS platforms offer plugins for wkhtmltopdf integration:

WordPress PDF export plugins
Drupal PDF generation modules
Custom CMS integrations via command-line calls

Database Report Generation

import mysql.connector
import subprocess

# Connect to database
conn = mysql.connector.connect(user='user', password='pass', host='localhost', database='sales')
cursor = conn.cursor()

# Get data
cursor.execute("SELECT * FROM monthly_report")
data = cursor.fetchall()

# Generate HTML
html = "<html><body><h1>Monthly Report</h1><table>"
for row in data:
    html += f"<tr><td>{row[0]}</td><td>{row[1]}</td></tr>"
html += "</table></body></html>"

# Save HTML and convert to PDF
with open('report.html', 'w') as f:
    f.write(html)

subprocess.call(['wkhtmltopdf', 'report.html', 'monthly_report.pdf'])

Automated Document Generation with Cron

Create a scheduled task for regular report generation:

crontab -e
# Add this line for daily execution at 1 AM
0 1 * * * /usr/bin/wkhtmltopdf https://internal.reports.example.com/daily /var/reports/daily-$(date +\%Y\%m\%d).pdf

Integration with Web Services

For microservice architectures:

// Node.js example
const express = require('express');
const { exec } = require('child_process');
const app = express();

app.post('/convert', (req, res) => {
  const url = req.body.url;
  const outputFile = `/tmp/output-${Date.now()}.pdf`;
  
  exec(`wkhtmltopdf ${url} ${outputFile}`, (error) => {
    if (error) {
      return res.status(500).send('Conversion failed');
    }
    res.download(outputFile);
  });
});

app.listen(3000);

These integrations demonstrate how wkhtmltopdf can serve as a critical component in document processing pipelines, reporting systems, and web services.

Security Considerations

When deploying wkhtmltopdf in production environments, security deserves careful attention:

Restricted User Execution

Run wkhtmltopdf under a dedicated user with limited permissions:

sudo useradd -r -s /bin/false wkhtmluser
sudo -u wkhtmluser wkhtmltopdf input.html output.pdf

URL Validation

When accepting URLs from user input, implement strict validation:

import re
import subprocess

def convert_url(url):
    if not re.match(r'^https?://[a-zA-Z0-9][-a-zA-Z0-9.]*\.[a-zA-Z]{2,}', url):
        raise ValueError("Invalid URL format")
    
    # Additional checks for allowed domains
    allowed_domains = ['trusted-domain.com', 'internal-site.org']
    if not any(domain in url for domain in allowed_domains):
        raise ValueError("Domain not allowed")
        
    subprocess.call(['wkhtmltopdf', url, 'output.pdf'])

Sandbox Configuration

Use systemd features to restrict wkhtmltopdf’s access:

[Service]
Type=simple
User=wkhtmluser
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ExecStart=/usr/bin/wkhtmltopdf input.html output.pdf

Resource Limitations

Prevent resource exhaustion attacks:

wkhtmltopdf --load-error-handling ignore --load-media-error-handling ignore --javascript-delay 5000 input.html output.pdf

Regular Updates

Stay vigilant about security updates, as wkhtmltopdf processes potentially untrusted content and security vulnerabilities could lead to system compromise.

Congratulations! You have successfully installed Wkhtmltopdf. Thanks for using this tutorial for installing the Wkhtmltopdf on Fedora 42 system. For additional help or useful information, we recommend you check the official Wkhtmltopdf website.

VPS Manage Service Offer

If you don’t have time to do all of this stuff, or if this is not your area of expertise, we offer a service to do “VPS Manage Service Offer”, starting from $10 (Paypal payment). Please contact us to get the best deal!