# AI Development Blueprint Generator (`bread-kim/ai-development-blueprint-generator`) Actor

Turn product requirements into a validated development blueprint for AI coding agents. Generate structured requirements, screens, components, APIs, data models, tests, implementation rules, and a ready-to-use project package.

- **URL**: https://apify.com/bread-kim/ai-development-blueprint-generator.md
- **Developed by:** [bread kim](https://apify.com/bread-kim) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.05 / actor start

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

## AI Development Blueprint Generator

### Structured capability contract (graph schema 2.0)

`capabilityPolicy[]` is the only capability authority. Each bounded entry has
`capabilityId`, `REQUIRED|ALLOWED|FORBIDDEN`, and explicit source/evidence IDs;
required/allowed/forbidden lists are derived views and are not graph fields.
Every implementation-bearing node in the eleven supported collections requires
`capabilityRefs` (including `[]`). Typed API/entity/auth/storage dependencies,
unknown IDs, missing refs, duplicate/conflicting dispositions, forbidden refs,
and implementation-bearing OUT_OF_SCOPE nodes fail closed.

Descriptions, purposes, notes, observations, evidence excerpts, and other free
text are inert context. They are not parsed as capability security policy and
cannot populate AGENTS.md, CODEX_INSTRUCTIONS.md, implementation tasks, or API
rules. Context Markdown is JSON encoded with fence-breaking backticks escaped;
frontend context is serialized as JSON data rather than executable JSX/HTML/CSS.

Normal PREPARE/COMPILE/Generate/Validate paths accept canonical graph schema
`2.0`. Legacy graph schema `1.0` is not silently accepted. The one approved
historical packet/graph pair can be converted only by the explicit hash-bound
adapter; ambiguity returns `MIGRATION_NEEDS_AGENT_CORRECTION`. This is a
deterministic structured compiler, not a general natural-language security
interpreter. Future legacy packets are not auto-migrated: they require a new,
reviewed, explicitly versioned exact adapter or a fresh schema-2.0 PREPARE and
external-agent graph.

### What this Actor does

Turn project briefs or AI-authored canonical project graphs into consistent, traceable development blueprints. The Actor is a deterministic compiler, validator, renderer, and packager—not another required AI model and not a deployed customer application.

It generates linked requirements, business rules, flows, screens, design tokens, component contracts, conditional API/database specifications, acceptance criteria, planned tests, a representative React/TypeScript starter, `AGENTS.md`, development instructions, manifest, and `PROJECT_BLUEPRINT.zip`.

### For AI agents

The primary caller is an external coding agent such as Codex, Claude Code, Cursor Agent, Gemini-family agents, OpenAI agents, or another MCP/API client. The external agent performs reasoning and writes `candidateGraph`; this Actor enforces the canonical contract and creates the package.

All core results are machine-readable. See `AGENT_CONTRACT.md` for ownership, trust boundaries, statuses, and finding shape.

### Agent mode — no API key required

Agent mode is the default. Omitted `mode` and `operation` mean `agent` / `prepare`.

- `prepare`: Convert a project brief into a constrained generation packet and canonical graph contract for an external AI agent. No model API key required.
- `compile`: Validate and compile an AI-authored canonical project graph into a traceable development blueprint, design system, starter, and handoff package.
- `validate`: Use `mode=validate` to validate an existing blueprint graph/package for traceability, consistency, design-token fidelity, and artifact integrity.

Agent-mode OpenAI/customer-model calls: 0. Actor-internal Codex calls: 0. Agent keys and model options are rejected. PREPARE may fetch declared public HTTPS sources only when the user explicitly consents; COMPILE never re-fetches packet sources.

### PREPARE → COMPILE example

PREPARE:

```json
{
  "mode": "agent",
  "operation": "prepare",
  "language": "en",
  "project": {
    "name": "Tiny Tasks",
    "brief": "A small task list for individual users with create, complete, and delete flows.",
    "contextType": "greenfield",
    "targetUsers": ["individual"],
    "goals": ["track tasks"],
    "mustHave": ["create task"],
    "mustNotHave": ["payment", "admin"]
  },
  "capabilityPolicy": [
    { "capabilityId": "LOCAL_STORAGE", "disposition": "ALLOWED", "evidenceRefs": [] },
    { "capabilityId": "PAYMENT", "disposition": "FORBIDDEN", "evidenceRefs": ["SRC-PROJECT-BRIEF"] }
  ],
  "privacy": {
    "allowExternalLlmProcessing": false,
    "allowPublicWebsiteFetch": false,
    "sourceRightsConfirmed": true
  }
}
```

The `READY_FOR_AGENT` output includes the inline `packet`, its `packetId`/content hash, immutable source evidence, canonical graph schema, rules, and completion criteria. Give that packet—not hidden extra brief context—to the external agent.

COMPILE in a separate run:

```json
{
  "mode": "agent",
  "operation": "compile",
  "packetId": "AGP-...",
  "candidateGraph": { "...": "external agent canonical graph" }
}
```

The Actor resolves `packetId` only from its Actor-owned KVS READY record. COMPILE rejects caller-supplied packets, repositories, readers, resolvers, authority objects, and unrelated fields. Structural findings return `AGENT_CORRECTION_REQUIRED` with `code`, `nodeId`, and `requiredFix`. Provenance or contradiction findings return `QUALITY_FAILED`; genuine unresolved user choices return `NEEDS_DECISION`.

### Output package

Successful COMPILE stores `BLUEPRINT`, `BLUEPRINT_PACKAGE`, `ARTIFACT_MANIFEST`, `QUALITY_REPORT`, and optional `PREVIEW_HTML`, then lists only successfully stored records in `OUTPUT.artifacts`. The ZIP contains `blueprint.json`, `manifest.json`, connected documents/contracts, design assets, starter, and QA records under `PROJECT_BLUEPRINT/`.

Representative screens use explicit mock data. Domain-specific components are contracts unless starter coverage says they are implemented. Test cases remain `PLANNED`.

### Validation guarantees

COMPILE reuses the strict canonical JSON schema, provenance/evidence checks, source identity checks, explicit user-decision checks, exclusion/contradiction detection, typed relationship validation, requirement-to-acceptance/test mapping, conditional screen/API/entity checks, DTCG token/component validation, deterministic renderer, and manifest/ZIP path handling.

ZIP validation bounds encoded, archive, entry, and expanded sizes; rejects unsafe/duplicate paths; checks CRC, schema, exact manifest enumeration, bytes/hashes, graph quality, and deterministic graph/artifact equality. It is not a customer backend run, browser certification, full WCAG audit, or proof that planned tests passed.

### Optional human/BYOK Generate mode

An API key is only required for optional Generate mode. It must be selected explicitly with `mode=generate` and `operation=generate`; `provider=openai` is the only accepted provider value. Contradictory or omitted mode/provider is rejected before provider construction. Generate retains the fixed customer-BYOK OpenAI Responses path (`gpt-5.6-sol`, medium, `store:false`), bounded call/token/USD ledger, repair ceiling, and uncertain-call hard stop.

The key is the customer's OpenAI API key, not a developer Codex login. Customer requests never call back to the developer's computer. Actual customer API runtime remains unverified; no live Generate claim is made.

### Pricing

Agent-mode proposal: charge for deterministic compilation/validation and successful ZIP delivery, with no model API cost from this Actor. Generate-mode proposal: the Actor charge plus the customer's separate BYOK model bill. Pricing is a draft only and has not been applied; see `PRICING_PROPOSAL.md`.

### Security

Source snapshots are inert and never installed/executed. Generated customer/model text is serialized as data rather than inserted into JSX/HTML/CSS syntax. Public-source collection retains HTTPS, DNS/IP, redirect, timeout, and SSRF controls. Agent mode forbids provider keys/options and has no internal model repair. See `SECURITY_REVIEW.md`.

### Limitations

Local deterministic Agent contract tests use fixtures; a fake provider or hand-authored graph is not genuine external-agent/API/Apify evidence. This local turn did not run external agents, paid APIs, Apify, Docker/services, an independent focused reviewer, or publication/pricing/icon mutations. `AGENT_MODE_VERIFIED`, `APIFY_PRIVATE_AGENT_VERIFIED`, `OPTIONAL_BYOK_GENERATE_VERIFIED`, and `SELLABLE_READINESS` remain NO pending the separate host workflow. No sellability claim is made.

Local checks:

```sh
pnpm typecheck
pnpm build
pnpm test
pnpm audit --prod --audit-level high
```

# Actor input Schema

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

Agent is the default deterministic compiler workflow. Generate is optional customer-BYOK. Validate checks an existing graph/package without a model.

## `schemaVersion` (type: `string`):

Input contract version.

## `operation` (type: `string`):

PREPARE converts a brief to a constrained packet. COMPILE validates and packages an external-agent graph. GENERATE is optional BYOK. VALIDATE checks a graph or ZIP.

## `provider` (type: `string`):

Optional fixed provider selector for mode=generate. The only supported value is openai; forbidden in Agent and Validate modes.

## `language` (type: `string`):

Language for generated handoff content.

## `project` (type: `object`):

Project name, brief, context, users, goals, scope, and prohibitions. Runtime parsing enforces the closed nested shape.

## `capabilityPolicy` (type: `array`):

Required sole capability authority. Entries use a bounded capabilityId, REQUIRED/ALLOWED/FORBIDDEN disposition, and exact source/evidence IDs. Free text never changes this policy.

## `sources` (type: `object`):

Documents, HTTPS sites, and inert repository snapshots. Runtime parsing enforces IDs, paths, size, and nested types.

## `stack` (type: `object`):

Supported frontend, styling, backend, and database choices.

## `brand` (type: `object`):

Brand references and explicit customer styling constraints.

## `decisions` (type: `array`):

Answers supplied by the user for questions from a previous run.

## `assumptionPolicy` (type: `object`):

Controls low-risk defaults and blocking unresolved decisions.

## `previousBlueprint` (type: `object`):

Required for validate and for explicit bounded incremental generation.

## `packetId` (type: `string`):

For COMPILE, resolve a packet only from the product's fixed private PREPARE authority store. Never accepts caller-selected storage or guesses a packet.

## `candidateGraph` (type: `object`):

Structured graph authored by the external AI agent for COMPILE, or an existing graph for VALIDATE.

## `packageBase64` (type: `string`):

Bounded base64 PROJECT_BLUEPRINT.zip input for VALIDATE. Paths, CRC, expansion size, manifest hashes, graph, and deterministic artifacts are checked.

## `artifactManifest` (type: `object`):

Optional manifest object for graph/artifact VALIDATE input.

## `incremental` (type: `object`):

For generate with previousBlueprint: changedNodeIds, changeInstructions, and optional maxAffectedNodes. Source/version changes require a separate clarified full generation.

## `validationArtifacts` (type: `object`):

Safe relative artifact paths mapped to text content.

## `openaiApiKey` (type: `string`):

Required only when mode=generate. Forbidden in Agent and Validate modes. Used only as the request authorization value.

## `llm` (type: `object`):

Fixed model and effort plus customer call and cost ceilings.

## `limits` (type: `object`):

Bounded source, graph, runtime, token, and archive limits.

## `privacy` (type: `object`):

External processing consent, website-fetch consent, and source-rights confirmation.

## `output` (type: `object`):

Select preview, starter, traceability, and artifact version options.

## Actor input object example

```json
{
  "mode": "agent",
  "schemaVersion": "1.0",
  "operation": "prepare",
  "language": "ko",
  "project": {
    "name": "Personal Reading Queue",
    "brief": "A single-person browser app saves book title and author, marks a book read or unread, filters by reading status, and deletes a book after explicit confirmation. All data stays in localStorage on this browser. No login, server, payments or external fetch. Validate required nonempty title and show recoverable storage errors.",
    "mustHave": [
      "save book with title and author",
      "mark book read or unread",
      "filter books by reading status",
      "confirm before deleting a book",
      "persist books in localStorage"
    ],
    "goals": [
      "organize a personal reading queue"
    ],
    "contextType": "greenfield",
    "targetUsers": [
      "individual"
    ],
    "mustNotHave": [
      "authentication",
      "payments",
      "server",
      "external paid API"
    ]
  },
  "capabilityPolicy": [
    {
      "capabilityId": "LOCAL_STORAGE",
      "disposition": "REQUIRED",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    },
    {
      "capabilityId": "AUTHENTICATION",
      "disposition": "FORBIDDEN",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    },
    {
      "capabilityId": "PAYMENT",
      "disposition": "FORBIDDEN",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    },
    {
      "capabilityId": "SERVER",
      "disposition": "FORBIDDEN",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    },
    {
      "capabilityId": "EXTERNAL_API",
      "disposition": "FORBIDDEN",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    },
    {
      "capabilityId": "EXTERNAL_FETCH",
      "disposition": "FORBIDDEN",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    }
  ],
  "stack": {
    "frontend": "react-typescript",
    "styling": "css-variables",
    "backend": "none",
    "database": "none",
    "preserveExisting": false
  },
  "privacy": {
    "allowExternalLlmProcessing": false,
    "allowPublicWebsiteFetch": false,
    "sourceRightsConfirmed": true
  }
}
```

# Actor output Schema

## `OUTPUT` (type: `string`):

Always written for a completed Actor process. Its artifacts array is authoritative and lists only run-owned records successfully stored before OUTPUT.

## `BLUEPRINT_PACKAGE` (type: `string`):

Conditional template: available only when OUTPUT.artifacts contains recordKey BLUEPRINT_PACKAGE after a successful Agent COMPILE or optional Generate storage write.

## `PREVIEW_HTML` (type: `string`):

Conditional template: available only when OUTPUT.artifacts contains recordKey PREVIEW_HTML after a successful preview storage write.

## `QUALITY_REPORT` (type: `string`):

Conditional template: available only when OUTPUT.artifacts contains recordKey QUALITY_REPORT after a successful storage write.

# 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 = {
    "mode": "agent",
    "schemaVersion": "1.0",
    "operation": "prepare",
    "language": "ko",
    "project": {
        "name": "Personal Reading Queue",
        "brief": "A single-person browser app saves book title and author, marks a book read or unread, filters by reading status, and deletes a book after explicit confirmation. All data stays in localStorage on this browser. No login, server, payments or external fetch. Validate required nonempty title and show recoverable storage errors.",
        "mustHave": [
            "save book with title and author",
            "mark book read or unread",
            "filter books by reading status",
            "confirm before deleting a book",
            "persist books in localStorage"
        ],
        "goals": [
            "organize a personal reading queue"
        ],
        "contextType": "greenfield",
        "targetUsers": [
            "individual"
        ],
        "mustNotHave": [
            "authentication",
            "payments",
            "server",
            "external paid API"
        ]
    },
    "capabilityPolicy": [
        {
            "capabilityId": "LOCAL_STORAGE",
            "disposition": "REQUIRED",
            "evidenceRefs": [
                "SRC-PROJECT-BRIEF"
            ]
        },
        {
            "capabilityId": "AUTHENTICATION",
            "disposition": "FORBIDDEN",
            "evidenceRefs": [
                "SRC-PROJECT-BRIEF"
            ]
        },
        {
            "capabilityId": "PAYMENT",
            "disposition": "FORBIDDEN",
            "evidenceRefs": [
                "SRC-PROJECT-BRIEF"
            ]
        },
        {
            "capabilityId": "SERVER",
            "disposition": "FORBIDDEN",
            "evidenceRefs": [
                "SRC-PROJECT-BRIEF"
            ]
        },
        {
            "capabilityId": "EXTERNAL_API",
            "disposition": "FORBIDDEN",
            "evidenceRefs": [
                "SRC-PROJECT-BRIEF"
            ]
        },
        {
            "capabilityId": "EXTERNAL_FETCH",
            "disposition": "FORBIDDEN",
            "evidenceRefs": [
                "SRC-PROJECT-BRIEF"
            ]
        }
    ],
    "stack": {
        "frontend": "react-typescript",
        "styling": "css-variables",
        "backend": "none",
        "database": "none",
        "preserveExisting": false
    },
    "privacy": {
        "allowExternalLlmProcessing": false,
        "allowPublicWebsiteFetch": false,
        "sourceRightsConfirmed": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bread-kim/ai-development-blueprint-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 = {
    "mode": "agent",
    "schemaVersion": "1.0",
    "operation": "prepare",
    "language": "ko",
    "project": {
        "name": "Personal Reading Queue",
        "brief": "A single-person browser app saves book title and author, marks a book read or unread, filters by reading status, and deletes a book after explicit confirmation. All data stays in localStorage on this browser. No login, server, payments or external fetch. Validate required nonempty title and show recoverable storage errors.",
        "mustHave": [
            "save book with title and author",
            "mark book read or unread",
            "filter books by reading status",
            "confirm before deleting a book",
            "persist books in localStorage",
        ],
        "goals": ["organize a personal reading queue"],
        "contextType": "greenfield",
        "targetUsers": ["individual"],
        "mustNotHave": [
            "authentication",
            "payments",
            "server",
            "external paid API",
        ],
    },
    "capabilityPolicy": [
        {
            "capabilityId": "LOCAL_STORAGE",
            "disposition": "REQUIRED",
            "evidenceRefs": ["SRC-PROJECT-BRIEF"],
        },
        {
            "capabilityId": "AUTHENTICATION",
            "disposition": "FORBIDDEN",
            "evidenceRefs": ["SRC-PROJECT-BRIEF"],
        },
        {
            "capabilityId": "PAYMENT",
            "disposition": "FORBIDDEN",
            "evidenceRefs": ["SRC-PROJECT-BRIEF"],
        },
        {
            "capabilityId": "SERVER",
            "disposition": "FORBIDDEN",
            "evidenceRefs": ["SRC-PROJECT-BRIEF"],
        },
        {
            "capabilityId": "EXTERNAL_API",
            "disposition": "FORBIDDEN",
            "evidenceRefs": ["SRC-PROJECT-BRIEF"],
        },
        {
            "capabilityId": "EXTERNAL_FETCH",
            "disposition": "FORBIDDEN",
            "evidenceRefs": ["SRC-PROJECT-BRIEF"],
        },
    ],
    "stack": {
        "frontend": "react-typescript",
        "styling": "css-variables",
        "backend": "none",
        "database": "none",
        "preserveExisting": False,
    },
    "privacy": {
        "allowExternalLlmProcessing": False,
        "allowPublicWebsiteFetch": False,
        "sourceRightsConfirmed": True,
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bread-kim/ai-development-blueprint-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 '{
  "mode": "agent",
  "schemaVersion": "1.0",
  "operation": "prepare",
  "language": "ko",
  "project": {
    "name": "Personal Reading Queue",
    "brief": "A single-person browser app saves book title and author, marks a book read or unread, filters by reading status, and deletes a book after explicit confirmation. All data stays in localStorage on this browser. No login, server, payments or external fetch. Validate required nonempty title and show recoverable storage errors.",
    "mustHave": [
      "save book with title and author",
      "mark book read or unread",
      "filter books by reading status",
      "confirm before deleting a book",
      "persist books in localStorage"
    ],
    "goals": [
      "organize a personal reading queue"
    ],
    "contextType": "greenfield",
    "targetUsers": [
      "individual"
    ],
    "mustNotHave": [
      "authentication",
      "payments",
      "server",
      "external paid API"
    ]
  },
  "capabilityPolicy": [
    {
      "capabilityId": "LOCAL_STORAGE",
      "disposition": "REQUIRED",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    },
    {
      "capabilityId": "AUTHENTICATION",
      "disposition": "FORBIDDEN",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    },
    {
      "capabilityId": "PAYMENT",
      "disposition": "FORBIDDEN",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    },
    {
      "capabilityId": "SERVER",
      "disposition": "FORBIDDEN",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    },
    {
      "capabilityId": "EXTERNAL_API",
      "disposition": "FORBIDDEN",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    },
    {
      "capabilityId": "EXTERNAL_FETCH",
      "disposition": "FORBIDDEN",
      "evidenceRefs": [
        "SRC-PROJECT-BRIEF"
      ]
    }
  ],
  "stack": {
    "frontend": "react-typescript",
    "styling": "css-variables",
    "backend": "none",
    "database": "none",
    "preserveExisting": false
  },
  "privacy": {
    "allowExternalLlmProcessing": false,
    "allowPublicWebsiteFetch": false,
    "sourceRightsConfirmed": true
  }
}' |
apify call bread-kim/ai-development-blueprint-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bread-kim/ai-development-blueprint-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/sgKXPac8etfcOds3v/builds/kk7V7JldYeLwbrwht/openapi.json