# Publisher .pub to PDF Converter: Batch, No Publisher Needed (`descriptive_orbit/publisher-pub-converter`) Actor

Convert Microsoft Publisher (.pub) files to PDF in bulk, without Publisher. Upload files or ZIP archives, or paste links. Get PDF (or archive-ready PDF/A), page images, text and editable ODG/DOCX, plus one ZIP with your folder structure kept. Pay only for files that convert.

- **URL**: https://apify.com/descriptive_orbit/publisher-pub-converter.md
- **Developed by:** [Orbit Data Tools](https://apify.com/descriptive_orbit) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 converted files

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Publisher .pub to PDF Converter: Batch, No Publisher Needed

Convert **Microsoft Publisher (.pub) files to PDF in bulk**, without Publisher, without Windows and without uploading files one by one to a website. Give the Actor links to your .pub files or to ZIP archives full of them (Google Drive, Dropbox, OneDrive/SharePoint, any direct link), or upload them to Apify storage. You get one row per file with a PDF link, plus one ZIP of everything, named after your originals, with your folder structure kept.

Microsoft retired Publisher on **October 1, 2026**: Microsoft 365 no longer includes it, and Microsoft's own advice is to convert .pub files to PDF or Word while you still can. Microsoft's batch-conversion route is a PowerShell script that needs Windows *and* a working copy of Publisher. This Actor needs neither.

### What you get for every file

| Format | What it is | Good for |
|---|---|---|
| **PDF** (default) | Print-ready PDF of every page | Sharing, printing, archiving |
| **PDF/A-2b** (option) | ISO archiving standard: fonts embedded, no external links | Retiring a Publisher archive for good, records management |
| **PNG** | One image per page (50–300 DPI) | Websites, social posts, previews, thumbnails |
| **Text (.txt)** | The text of every page, laid out like the page | Search, indexing, feeding AI tools, copy-paste |
| **ODG** | Editable drawing for LibreOffice Draw (free) | Editing layouts without Publisher |
| **DOCX** (beta) | Word document with positioned text boxes | Quick text edits in Word |

All formats you pick are included in the one per-file price.

### Who it is for

- **Schools, churches, clubs, councils and small businesses** with years of newsletters, flyers, bulletins and brochures in .pub format.
- **IT admins** migrating a shared drive away from Publisher before people lose access.
- **Archivists and records managers** who need PDF/A copies of legacy files.
- **Mac and Linux users** who were sent a .pub file and have nothing to open it with.
- **Developers and AI agents** that need .pub support in a pipeline (Apify API, webhooks, MCP server).

### How to use it

**With links (fastest):**

1. Paste links into **Links to Publisher files or ZIP archives**, one per line. Google Drive, Dropbox and OneDrive/SharePoint links work when the file or folder ZIP is shared as "Anyone with the link"; they are turned into direct downloads automatically. Any other direct https:// link works too.
2. Pick the **output formats** (PDF is selected by default).
3. Start the run. Each file appears as a row with its links as soon as it is converted.
4. Download single files from the table, or everything as **converted-files.zip** (the link is in the run's `OUTPUT` record, under Storage > Key-value store).

**With files from your computer:**

1. Under the links field, click **Upload new files**, choose **New permanent storage**, give it a name (for example `publisher-files`) and upload your .pub files or ZIP archives.
2. In **Uploaded files: the storage you uploaded them to**, select that storage. Apify only lets tools read storages you select, which keeps the rest of your account private.
3. Start the run. Every file in that storage is converted once.

### Input example

```json
{
    "files": [
        "https://drive.google.com/file/d/1AbC.../view?usp=sharing",
        "https://www.dropbox.com/scl/fi/xyz/Newsletters-2019-2024.zip?rlkey=abc&dl=0"
    ],
    "outputFormats": ["pdf", "png", "txt"],
    "pdfA": false,
    "imageDpi": 150,
    "bundleZip": true
}
```

Files you uploaded instead: `{"filesStore": "publisher-files", "outputFormats": ["pdf"]}` (the storage name or ID).

### Output example

One row per input file:

```json
{
    "fileName": "Spring newsletter.pub",
    "archivePath": "Newsletters/2024/Spring newsletter.pub",
    "source": "https://www.dropbox.com/scl/fi/xyz/Newsletters-2019-2024.zip?rlkey=abc&dl=0",
    "status": "converted",
    "pages": 4,
    "pdfUrl": "https://api.apify.com/v2/key-value-stores/.../records/00003-Spring-newsletter.pdf?signature=...",
    "outputs": {
        "pdf": "https://api.apify.com/v2/key-value-stores/.../records/00003-Spring-newsletter.pdf?signature=...",
        "txt": "https://api.apify.com/v2/key-value-stores/.../records/00003-Spring-newsletter.txt?signature=...",
        "png": ["https://.../00003-Spring-newsletter-p001.png?signature=...", "..."]
    },
    "inputBytes": 1630208,
    "warning": null,
    "error": null,
    "convertedAt": "2026-10-22T14:03:11Z"
}
```

| Field | Meaning |
|---|---|
| `fileName` | Original file name |
| `archivePath` | Path inside your ZIP (folders kept), or `null` |
| `status` | `converted`, `failed` or `skipped` |
| `pages` | Number of pages in the PDF |
| `pdfUrl` | Link to the PDF (also in `outputs.pdf`) |
| `outputs` | Links for every format you picked (`png` is a list, one link per page) |
| `warning` | For example, no text found (image-only pages) or a format that could not be made |
| `error` | Why a file was skipped or failed |

The run's `OUTPUT` record has the totals and `zipUrls`, the links to the ZIP of everything.

### Pricing

Pay per converted file: **$0.03 per file** (less on higher Apify plans), with every output format included, plus a $0.005 start fee per run. **Files that fail or are skipped are free**: damaged files, password-protected entries, non-Publisher files, broken links. Set a maximum cost per run and the Actor stops converting when it is reached.

Example: an archive of 300 newsletters costs about $9.

### How it works and what to expect

The Actor runs LibreOffice, whose Publisher import (libmspub) reads files from Publisher 97 onwards, including Publisher 2019 and Microsoft 365. Files from Publisher 95 and older are not supported (they are listed as failed and are free). Most text, shapes, tables and pictures come through.

**Our test results.** We ran 18 real Publisher files through it, 13 of them files that people had reported to LibreOffice as hard to open. 16 converted. The other 2 (a Publisher 2.0 file and one with an unusual text encoding) came out blank, so they were marked failed and were free. In 3 of the 16, some details came out simpler (WordArt missing, a title overlapping). Plain newsletters, flyers, certificates and booklets came through well. Speed: about half a second per file once LibreOffice has started.

Things to know:

- **Fonts.** Your files' fonts are not inside the .pub file. Common Microsoft fonts are replaced with free look-alikes that have the same letter widths (Arial, Times New Roman, Courier New, Calibri, Cambria). Rare fonts fall back to a similar font, so text can wrap slightly differently.
- **Complex effects.** WordArt, some text effects and unusual borders may look simpler than in Publisher.
- **Check your important files.** Open a few PDFs from each batch before you delete any originals. Keep the .pub files until you are happy.
- **DOCX is beta.** It is made from the PDF, so the layout is kept with text boxes. That is fine for small edits but not for re-flowing long text.

### Privacy

Files are processed inside your own Apify run and stored in your run's storage, which only you can open unless you share the links. The output links are signed links: anyone who has a link can open that one file, so share them with care. Storage is removed according to your Apify plan's data retention. The Actor never sends your files anywhere else.

### FAQ

**Can I open .pub files on a Mac?** Not with Microsoft software: Publisher never had a Mac version. This Actor converts them in the cloud, so you only need a browser.

**What about password-protected or corrupt files?** They are listed with `status: "failed"` and an explanation, and they are free.

**Can I call it from code or an AI agent?** Yes. Use the Apify API or any Apify client with `files` set to your links. For AI agents, add this Actor to Apify's MCP server (mcp.apify.com), which exposes it as a tool for Claude, Cursor and other MCP clients, so an agent can turn a .pub link into a PDF link and its text.

**Why does a blank result count as failed?** If the pages come out empty, the converter could not read that file (very old Publisher versions, for example). Such files are marked `failed` and you are not charged.

**What happened to Publisher?** Microsoft ended support on October 1, 2026. Microsoft 365 apps no longer include Publisher, and Microsoft recommends converting files to PDF or Word.

This Actor is not affiliated with or endorsed by Microsoft. Microsoft and Publisher are trademarks of Microsoft Corporation.

# Actor input Schema

## `files` (type: `array`):

Paste links: direct download links, or Google Drive, Dropbox and OneDrive/SharePoint links shared as "Anyone with the link". ZIP archives are unpacked and their folders kept. To upload files from your computer instead: click "Upload new files", choose "New permanent storage" and give it a name, then select that storage in the next field (Apify only lets tools read storages you select). Files that are not Publisher files are skipped for free.

## `filesStore` (type: `string`):

Select the key-value store that holds your uploaded .pub files or ZIP archives. Every file in it is converted (one file per record; the record name becomes the file name).

## `outputFormats` (type: `array`):

PDF is the default. All formats you pick are included in the per-file price. PNG gives one image per page; Text is the plain text of every page (for search or AI tools); ODG opens and edits in LibreOffice Draw; DOCX (beta) opens in Word with text boxes placed like the original.

## `pdfA` (type: `boolean`):

Create PDF/A-2b files, the ISO standard for long-term archiving (fonts embedded, no external dependencies). Useful when you are retiring a Publisher archive for good.

## `imageDpi` (type: `integer`):

Resolution of the PNG page images. 150 is sharp on screen; 300 is print quality (bigger files).

## `bundleZip` (type: `boolean`):

Pack all converted files into converted-files.zip, named after your original files, with the folders from your ZIP archives kept. The link is in the run's OUTPUT record. Very large batches are split into parts of about 400 MB.

## `maxFiles` (type: `integer`):

Safety cap for big archives. Files over the limit get a free "skipped" row. Your maximum cost per run also limits how many files are converted.

## `fileTimeoutSecs` (type: `integer`):

A file that takes longer than this to convert is marked as failed (free) and the run carries on.

## Actor input object example

```json
{
  "files": [
    "https://raw.githubusercontent.com/apache/poi/trunk/test-data/publisher/Sample.pub"
  ],
  "outputFormats": [
    "pdf"
  ],
  "pdfA": false,
  "imageDpi": 150,
  "bundleZip": true,
  "maxFiles": 1000,
  "fileTimeoutSecs": 120
}
```

# Actor output Schema

## `results` (type: `string`):

One row per Publisher file with links to every output format, page count, and why a file was skipped or failed.

## `summary` (type: `string`):

Counts of converted, failed and skipped files, plus links to the bundle ZIP(s).

## `files` (type: `string`):

Every PDF, image, text, ODG/DOCX and ZIP file from this run.

# 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 = {
    "files": [
        "https://raw.githubusercontent.com/apache/poi/trunk/test-data/publisher/Sample.pub"
    ],
    "outputFormats": [
        "pdf"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("descriptive_orbit/publisher-pub-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 = {
    "files": ["https://raw.githubusercontent.com/apache/poi/trunk/test-data/publisher/Sample.pub"],
    "outputFormats": ["pdf"],
}

# Run the Actor and wait for it to finish
run = client.actor("descriptive_orbit/publisher-pub-converter").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "files": [
    "https://raw.githubusercontent.com/apache/poi/trunk/test-data/publisher/Sample.pub"
  ],
  "outputFormats": [
    "pdf"
  ]
}' |
apify call descriptive_orbit/publisher-pub-converter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,descriptive_orbit/publisher-pub-converter"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/bcTGVKvf8IhUvZbcA/builds/3qM3c3gsAa6Pc4sBy/openapi.json