# URL to PDF Converter (`rainminer/url-to-pdf-converter`) Actor

Converts any web page into a high-quality PDF document ready to download file hosted on Apify. Print any web page to PDF with this actor.

- **URL**: https://apify.com/rainminer/url-to-pdf-converter.md
- **Developed by:** [rainminer](https://apify.com/rainminer) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.99 / 1,000 pdfs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![URL to PDF Converter](https://upload.wikimedia.org/wikipedia/commons/thumb/8/87/PDF_file_icon.svg/267px-PDF_file_icon.svg.png)

### What is URL to PDF Converter?

**URL to PDF Converter** is an Apify Actor that turns any public web page into a downloadable PDF file. Powered by headless Chrome and Puppeteer, it renders pages exactly as a real browser would — including fonts, CSS backgrounds, and images — then saves each PDF to Apify's Key-Value Store with a direct download link.

Provide a list of URLs and get back a dataset of `pdfUrl` links ready for download, archiving, or integration into document workflows.

### What can URL to PDF Converter do? 📄

- 📑 **Convert any public URL to PDF** — full-fidelity render with fonts, backgrounds, and images preserved
- 🔗 **Batch conversion** — process a list of URLs in a single run, one PDF file per page
- 💾 **Automatic Key-Value Store storage** — each PDF is saved with a filename derived from the page title
- 🏷️ **Smart file naming** — filenames are sanitized automatically from the page title
- 🖨️ **Print-ready A4 format** — standard A4 size, suitable for printing, sharing, and archiving
- 📦 **Direct download links** — dataset row per URL with a ready-to-use `pdfUrl`
- ⚡ **Fast** — waits for full page load and network idle before rendering; no extra scraping passes

### What data does URL to PDF Converter output?

| Field    | Description                                           | Example                                                                       |
| -------- | ----------------------------------------------------- | ----------------------------------------------------------------------------- |
| `url`    | The original web page URL that was converted          | `"https://example.com/report"`                                                |
| `pdfUrl` | Direct download link to the generated PDF in storage  | `"https://api.apify.com/v2/key-value-stores/{storeId}/records/Report.pdf"`   |

PDFs themselves are stored in the **Key-Value Store** tab of your Apify run, accessible without any extra API calls.

### How to convert URLs to PDF

1. Open [URL to PDF Converter](https://apify.com/rainminer/url-to-pdf-converter) on Apify Store and click **Try for free**.
2. Add your **Start URLs** — paste one or more web page URLs into the URL list.
3. (Optional) Configure a **proxy** if pages are geo-restricted or rate-limited.
4. Click **Start** — the Actor opens each page in headless Chrome, waits for full render, and saves the PDF.
5. **Download your PDFs** from the Key-Value Store tab, or use the `pdfUrl` links from the dataset.

### How much does it cost to convert URLs to PDF?

URL to PDF Converter uses **consumption-based pricing** on the Apify platform (Compute Units). Apify offers **$5 of free credits** every month on the Free plan — enough for a large number of conversions.

Cost depends on page complexity and render time. Simple pages typically complete in a few seconds each. No browser image is pre-warmed on cold starts, so the first run may take slightly longer.

### Input

| Field                | Type    | Default               | Description                                                                          |
| -------------------- | ------- | --------------------- | ------------------------------------------------------------------------------------ |
| `startUrls`          | Array   | —                     | Web page URLs to convert to PDF. Required. Each entry can include custom headers.    |
| `proxyConfiguration` | Object  | `{useApifyProxy: false}` | Proxy settings. Enable Apify Proxy if pages are geo-restricted or rate-limited.   |

**Example input:**

```json
{
  "startUrls": [
    { "url": "https://example.com/report" },
    { "url": "https://example.com/invoice" }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Output example

```json
{
  "url": "https://example.com/report",
  "pdfUrl": "https://api.apify.com/v2/key-value-stores/{storeId}/records/Report_Page.pdf"
}
```

You can download PDFs directly from the **Key-Value Store** tab in Apify Console, or access them programmatically via the `pdfUrl` from the dataset output.

### FAQ

#### Can I convert multiple pages at once?

Yes. Add as many URLs as you need to `startUrls`. Each URL is processed in sequence and saved as a separate PDF file in the Key-Value Store.

#### How do I download the generated PDFs?

Open the **Key-Value Store** tab in Apify Console after the run completes and click any `.pdf` entry to download it. You can also use the `pdfUrl` values in the dataset to fetch PDFs programmatically.

#### Can I pass custom headers (e.g. for authentication)?

Yes. Each entry in `startUrls` supports a `headers` object. Add `Authorization`, `Cookie`, or any other HTTP header your target page requires.

#### What PDF format is used?

PDFs are generated in **A4 format** with print backgrounds enabled and fonts fully loaded before capture. This matches the standard used by most document management systems.

#### What happens if a page fails to load?

The Actor waits for network idle before generating the PDF. If the page does not load properly, the PDF will reflect whatever state the browser reached (e.g. an error page). The run will not stop — other URLs in the batch continue.

#### Are the PDF download links publicly accessible?

PDF URLs in the dataset are accessible to anyone with the link if your Key-Value Store is set to public. You can control access in your Apify account settings.

***

### Image Credit

Image credit: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:PDF_file_icon.svg)

# Actor input Schema

## `startUrls` (type: `array`):

List of web page URLs to convert to PDF. Each URL will produce one PDF file in the Key-Value Store.

## `proxyConfiguration` (type: `object`):

Proxy settings for the browser. Enable Apify Proxy if target pages are geo-restricted or rate-limited.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://apify.com"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rainminer/url-to-pdf-converter").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://apify.com" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rainminer/url-to-pdf-converter").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rainminer/url-to-pdf-converter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=rainminer/url-to-pdf-converter",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "URL to PDF Converter",
        "description": "Converts any web page into a high-quality PDF document ready to download file hosted on Apify. Print any web page to PDF with this actor.",
        "version": "1.0",
        "x-build-id": "sUDbp0hColSTDCaTA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rainminer~url-to-pdf-converter/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rainminer-url-to-pdf-converter",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/rainminer~url-to-pdf-converter/runs": {
            "post": {
                "operationId": "runs-sync-rainminer-url-to-pdf-converter",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/rainminer~url-to-pdf-converter/run-sync": {
            "post": {
                "operationId": "run-sync-rainminer-url-to-pdf-converter",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of web page URLs to convert to PDF. Each URL will produce one PDF file in the Key-Value Store.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the browser. Enable Apify Proxy if target pages are geo-restricted or rate-limited."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
