# Daily Logic Puzzle API & Archive - PUZRU (`eijomind/puzru-daily-logic-puzzle-api`) Actor

Fetch two verified 6×6 cage-sum logic puzzles every day or retrieve any completed PUZRU World round by ID. Get clean JSON for websites, apps, widgets, classrooms, and automations without scraping, browser automation, or operating your own puzzle generator.

- **URL**: https://apify.com/eijomind/puzru-daily-logic-puzzle-api.md
- **Developed by:** [Puzru Team](https://apify.com/eijomind) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Daily Logic Puzzle API & Archive — PUZRU

Fetch verified completed 6×6 cage-sum logic puzzles as structured JSON.

This Actor provides a thin, read-only integration over PUZRU's canonical puzzle distribution service. It does not scrape websites, run browser automation, or generate puzzles locally.

### What this Actor does

Use the Actor to retrieve:

- today's two-puzzle Daily set
- one completed puzzle by round ID
- 6×6 puzzle structure
- givens
- arithmetic cages and cage sums
- difficulty metadata
- completed round metadata
- attribution and puzzle URLs

The puzzle format combines Latin-grid deduction with arithmetic cage sums, making it useful for logic puzzle, math puzzle, number puzzle, and grid puzzle applications.

### Daily mode

Choose `daily` to retrieve today's Daily set.

```json
{
  "mode": "daily"
}
```

The result contains two completed puzzles:

- `warmup` — the easier Daily puzzle
- `challenge` — the harder Daily puzzle

Each run stores one canonical response object in the Actor's default dataset.

### Completed round mode

Choose `round` and provide a positive completed round ID.

```json
{
  "mode": "round",
  "roundId": 21
}
```

The Actor returns the immutable completed puzzle associated with that round.

If the requested round does not exist or is not available, the run fails rather than returning fabricated or partial puzzle data.

### Input

#### `mode`

Type: `string`

Available values:

- `daily`
- `round`

Default:

```text
daily
```

#### `roundId`

Type: `integer`

Required when:

```text
mode = round
```

The value must be a positive completed round ID.

### Output

The Actor stores one JSON item in its default dataset.

A Daily response can include fields such as:

```text
ok
apiVersion
profile
daily
set
roundId
puzzle
contributors
discoverer
quality
urls
attribution
```

A completed round response can include:

```text
ok
apiVersion
profile
roundId
difficulty
puzzle
contributors
discoverer
quality
urls
attribution
```

### Puzzle structure

Puzzle data can contain:

#### `size`

The PUZRU puzzle grid size.

Current distributed puzzles use a 6×6 grid.

#### `givens`

Pre-filled cell values indexed by cell position.

#### `cages`

Arithmetic cage definitions.

Each cage contains:

```json
{
  "cells": [7, 8, 9, 14],
  "sum": 15
}
```

### Read-only by design

The Actor distributes completed puzzle data only.

It does not expose:

- canonical puzzle solutions
- live competitive state
- player sessions
- authentication credentials
- claim tokens
- account information
- puzzle-generation internals
- mutable gameplay operations

### No scraping or browser automation

This Actor does not parse webpages or automate a browser.

It retrieves structured puzzle data directly from the canonical PUZRU distribution service and stores the response in an Apify dataset.

This makes it suitable for workflows that need predictable structured JSON without DOM parsing or browser dependencies.

### Example use cases

The Actor can be used for:

- daily logic puzzle workflows
- puzzle widgets
- websites and apps
- education and classroom tools
- automation workflows
- structured puzzle datasets
- prototype logic games
- math and grid puzzle experiments
- agent and data-pipeline integrations

### Reliability

Completed archive puzzles are immutable.

The Actor validates the upstream response before writing it to the dataset. Unexpected or unavailable responses cause the run to fail instead of producing misleading output.

Network requests also use a bounded timeout.

### Security and privacy

The Actor uses a private server-to-server marketplace credential to identify trusted Apify traffic.

The credential is configured as a secret environment variable and is not part of Actor input or output.

The Actor does not require end users to provide:

- PUZRU accounts
- PUZRU API keys
- passwords
- authentication cookies
- personal information

### Storage

Each successful run writes exactly one canonical API response to the default Apify dataset.

The dataset can then be consumed through Apify's standard dataset APIs and export formats.

# Actor input Schema

## `mode` (type: `string`):

Daily returns today's warm-up and challenge. Round returns one completed archive puzzle.

## `roundId` (type: `integer`):

Positive completed PUZRU World round ID. Used only when mode is round.

## Actor input object example

```json
{
  "mode": "daily"
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("eijomind/puzru-daily-logic-puzzle-api").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("eijomind/puzru-daily-logic-puzzle-api").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 '{}' |
apify call eijomind/puzru-daily-logic-puzzle-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,eijomind/puzru-daily-logic-puzzle-api"
        }
    }
}
```

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/hgvh5EF8seSHyi21O/builds/ZBqm3TWqRlsS9RF33/openapi.json