# Printable Puzzle PDF Generator: word search, sudoku, maze (`atarivo/printable-puzzle-pdf-generator`) Actor

Returns one printable PDF of word search, sudoku, maze or nonogram puzzles with an answer key, plus one dataset row per puzzle (page, answer page, seed, PDF link). Every puzzle is solver-verified to have exactly one solution. Letter or A4. First 3 puzzles per run free. No network, no AI.

- **URL**: https://apify.com/atarivo/printable-puzzle-pdf-generator.md
- **Developed by:** [Atarivo Enterprises Inc.](https://apify.com/atarivo) (community)
- **Categories:** Developer tools, Education, For creators
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 puzzle rendereds

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

Printable Puzzle PDF Generator makes word search, sudoku, maze and nonogram (picture logic)
puzzles and returns them as one printable PDF with an answer key, plus one result row per
puzzle. Every puzzle is checked by a solver to have exactly one solution before it is drawn.
It is built for teachers, parents, activity-sheet makers and puzzle-book publishers who want
ready-to-print pages in one call. To try it, keep the sample input (4 word searches) and press
**Start**. The run takes a few seconds.

### What does the Printable Puzzle PDF Generator do?

- **Returns one PDF**: every puzzle on its own page, then the answer key, one answer page per
  puzzle. Each page has a title line ("Word search 3 of 4"), a page number, and the puzzle page
  says which page holds its answer.
- **Four puzzle types**:
  - **Word search generator**: 15x15 grid, up to 20 words, large letters. Use the built-in
    family-friendly themed word lists or your own words.
  - **Sudoku**: classic 9x9, easy to hard by number of given digits.
  - **Maze**: rectangular perfect maze (exactly one path), entrance top left, exit bottom right.
  - **Nonogram** (griddler, picross): picture logic puzzles at 15x15, 20x20 or 25x25 from a
    library of pixel pictures; the answer key shows the picture.
- **Solver-verified answer key**: a solver that reads only the printed clues must find exactly
  one solution, and it must match the answer key. A puzzle that fails is never printed.
- **Reproducible**: give a `seed` and you get the same puzzles and the same PDF again.
- US Letter or A4 pages. Makes **no network calls** and calls **no AI model**: the puzzles come
  from code alone.

### How to use the printable puzzle PDF generator

1. Choose a **Puzzle type**, the **Number of puzzles** (1 to 50) and a **Difficulty**.
2. For a word search, optionally paste **Your words** (5 to 40 words, letters only).
3. Pick **Page size** (US Letter or A4) and press **Start**.
4. Open the **Output** tab and click the PDF link (every row carries it), or read `pdf_url`
   from the dataset API. Print at 100% ("Actual size").

Calling it from an AI agent: `{"puzzle": "sudoku", "count": 10, "difficulty": "hard"}`. The
description above is also the Actor's tool description in the Apify MCP server.

### Pricing

| Event | What you pay for | Price |
|---|---|---|
| `puzzle-rendered` | One verified puzzle and its answer page saved in the PDF | $0.020 |

**The first 3 puzzles of every run are free**, so a run of up to 3 puzzles costs nothing in
events. You pay only for puzzles that were saved in the PDF. Set **Max cost per run** to cap a
run: the Actor makes only as many puzzles as the cap covers, the PDF holds exactly those, and
the status message says so. Platform usage is included (no "+usage" charges).

### Input

| Field | Type | Required | Notes |
|---|---|---|---|
| `puzzle` | string | yes | `wordsearch`, `sudoku`, `maze` or `nonogram`. |
| `count` | integer | yes | 1 to 50 puzzles. The PDF has twice as many pages (puzzles + answers). |
| `difficulty` | string | no | `easy`, `medium` (default) or `hard`. Word search: across/down, + diagonals, all 8 directions. Sudoku: 36-40, 30-35, 27-29 givens. Maze: 12x9, 18x13, 26x19. Nonogram: 15x15, 20x20, 25x25. |
| `pageSize` | string | no | `letter` (default) or `a4`. |
| `words` | array | no | Word search only. 5 to 40 words of 3 to 15 letters A-Z. A word may not sit inside another word. Up to 20 go into each puzzle. |
| `seed` | integer | no | 0 to 2147483647. Same seed + same input = same puzzles. |

```json
{ "puzzle": "wordsearch", "count": 4 }
```

### Output

One dataset row per puzzle:

```json
{
  "index": 1,
  "puzzle": "wordsearch",
  "difficulty": "medium",
  "title": "Word search 1 of 4",
  "page": 1,
  "answer_page": 5,
  "seed": 1834567,
  "pdf_url": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/puzzles.pdf",
  "pdf_key": "puzzles.pdf",
  "pdf_pages": 8,
  "page_size": "letter",
  "details": {"theme": "Farm Animals", "grid": "15x15", "words": ["BARN", "GOAT", "..."]}
}
```

The PDF is in the run's default key-value store under `puzzles.pdf`. Run storage is kept for
your plan's data-retention period (7 days for unnamed storages on most plans), then deleted by
Apify. Download the PDF to keep it. Your word list is used only inside your run.

### Other Actors by Atarivo

Every Atarivo Actor follows the same rules: limited permissions, no "+usage" pricing, charges
only after results are saved, and at least one result row per run.

- **[PDF, Image & Word to Text and Markdown (OCR)](https://apify.com/atarivo/pdf-image-text-markdown-extractor)**: returns the text, Markdown, tables and page facts of a PDF, PNG, JPEG, TIFF or Word .docx file, one dataset row per page, plus RAG chunks with page spans. OCR runs only on scanned or unreadable pages. First page free.
- **[ATS Jobs API: Greenhouse, Lever & Ashby](https://apify.com/atarivo/ats-jobs-api-greenhouse-lever-ashby)**: every open job on the Greenhouse, Lever and Ashby boards you list, one row per job: title, company, location, remote flag, department, posted date and apply URL. No login, no personal data.

### FAQ, disclaimers and support

**Can I use it for KDP puzzle books or classroom worksheets?** Classroom, home and party use
work as they are: print the PDF. For an Amazon KDP interior, treat the PDF as source pages, not
a finished book: it is US Letter or A4 (not a KDP trim size), it has no front matter, and it
uses the standard PDF font Helvetica, which is not embedded. KDP requires embedded fonts, so
re-export the pages through a layout tool that embeds fonts before you upload.

**Can I sell what I make?** The puzzles in your PDF are yours to print, share and use,
including in products you sell. Some nonogram pictures are drawn from open icon sets (MIT,
ISC, Apache 2.0 or CC BY 4.0); their answer page prints a one-line picture credit, and the
row's `details.picture_credit` repeats it. Keep that line with the picture.

**Why was my word list refused?** A word that sits inside another word (CAT in
CATERPILLAR), forwards or backwards, could never appear exactly once, so the Actor refuses it
and tells you which pair to fix.

**Fonts and attribution.** Pages use reportlab's built-in standard PDF fonts only; no font
file ships with the Actor, so there is nothing to license. The puzzle generators are
Atarivo's own code.

**Something is wrong.** Open an issue on the **Issues** tab with the run ID. Issues are
answered within 14 days.

This Actor is provided as is, under Apify's Standard Actor Contract. It is not affiliated with
or endorsed by Amazon or KDP.

# Actor input Schema

## `puzzle` (type: `string`):

Which puzzle to make: wordsearch (15x15 word search, 20 words), sudoku (classic 9x9), maze (rectangular maze, entrance top left, exit bottom right) or nonogram (picture logic puzzle from a library of pixel pictures). One type per run.

## `count` (type: `integer`):

How many puzzles to make, from 1 to 50. The PDF has one page per puzzle plus one answer-key page per puzzle. The first 3 puzzles of every run are free; each further puzzle is one charged event.

## `difficulty` (type: `string`):

easy, medium or hard. Word search: words run across and down (easy), also diagonally (medium), or in all 8 directions including backwards (hard). Sudoku: 36-40, 30-35 or 27-29 given digits. Maze: 12x9, 18x13 or 26x19 cells. Nonogram: 15x15, 20x20 or 25x25 grid. Default medium.

## `pageSize` (type: `string`):

letter (US Letter, 8.5 x 11 in) or a4 (210 x 297 mm). Default letter.

## `words` (type: `array`):

Optional, word search only: your own word list, 5 to 40 words, each 3 to 15 letters A-Z (no spaces, digits or accents). Up to 20 words go into each puzzle. Leave empty to use the built-in family-friendly themed lists (animals, food, weather, space and more), a different theme per puzzle.

## `seed` (type: `integer`):

Optional whole number from 0 to 2147483647. The same seed with the same other inputs gives exactly the same puzzles and the same PDF. Leave empty for new puzzles each run; the seed used is in every result row.

## Actor input object example

```json
{
  "puzzle": "wordsearch",
  "count": 4,
  "difficulty": "medium",
  "pageSize": "letter"
}
```

# Actor output Schema

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

One row per puzzle (index, puzzle, difficulty, title, page, answer_page, seed, pdf_url, pdf_key, pdf_pages, page_size, details): its page and answer-key page in the PDF, the seed and the PDF URL.

## `pdf` (type: `string`):

The PDF with every puzzle followed by the answer key, in the run's key-value store.

# 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 = {
    "puzzle": "wordsearch",
    "count": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("atarivo/printable-puzzle-pdf-generator").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 = {
    "puzzle": "wordsearch",
    "count": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("atarivo/printable-puzzle-pdf-generator").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 '{
  "puzzle": "wordsearch",
  "count": 4
}' |
apify call atarivo/printable-puzzle-pdf-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,atarivo/printable-puzzle-pdf-generator"
        }
    }
}
```

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/5leWMY2fClYqasFrm/builds/LlhiRJS7xRSOPSjxt/openapi.json