# Apify Desk

> Paste an Apify Actor project and run four lanes over it: actorize the script, author the input
> schema, generate the output schemas, and wire the client call that consumes it.

Live at https://apify-desk.skillsafe.ai/ · API at https://apify-desk.skillsafe.ai/api.html

## What it is for

One specific sitting: **turning a working scraper script into a publishable Apify Actor with a
correct input schema, output schemas and a client integration.** One work object — the Actor project
— and four lanes over it, in the order a person meets them.

## The work object

A paste containing any subset of an Actor project:

- the scraper or automation source, JavaScript, TypeScript or Python;
- `.actor/actor.json`, the Actor manifest;
- `INPUT_SCHEMA.json` or `.actor/input_schema.json`;
- `.actor/dataset_schema.json`, `.actor/output_schema.json`, `.actor/key_value_store_schema.json`;
- a `Dockerfile`, a `package.json` or a `requirements.txt`.

Multiple files are separated by a `// file: path` line (or `# file: path` for Python and
Dockerfiles). Drag-and-drop writes those markers for you. Nothing is uploaded by dropping a file.

## The four lanes

| `task` | What it does | Emits |
| --- | --- | --- |
| `actorize` | Names every gap between a plain script and an Actor, and ports it. | the rewritten entrypoint |
| `input` | Turns the options the code reads into a legal input schema. | `.actor/input_schema.json` |
| `output` | Describes what a run produces, field by field. | `.actor/dataset_schema.json` |
| `client` | Writes the `apify-client` call that runs it and reads the dataset back. | a runnable client module |

Lane A's emitted file hands off into lane B with a button: the input schema the `input` lane writes
becomes a document the `output` lane can see, and so on down the pipeline.

## What is free, and what costs credits

**Free, no account, no network, decided entirely in your browser:**

- a string-aware JSON scanner that finds every JSON document in the paste and classifies each one by
  its own shape — manifest, input schema, dataset schema, output schema, key-value store schema or
  package manifest — rather than by the filename it was pasted under;
- Actor manifest validation: `actorSpecification`, the name pattern, the two-part version pattern,
  `buildTag`, the input pointer and the declared storages;
- input schema validation against the real Apify rules, including **which `editor` each property
  type is allowed to use** — the single most common reason a hand-written `INPUT_SCHEMA.json` is
  rejected;
- the options the code actually reads, pulled out of the destructuring, the member reads and the
  Python `actor_input.get("key")` calls, with the default each one is given;
- the dataset fields the code actually pushes, read out of the object literal given to `pushData`
  (including one assembled into a named variable first), with an inferred type and a line number;
- a source lint: missing Actor lifecycle, missing `getInput`, an unawaited `pushData`, a hardcoded
  API token, a crawler with no proxy configuration;
- a sixteen-check status table and numbered flags with severity and line;
- a live edit delta after a run — which flags your edits cleared, which are still open, which your
  edits introduced;
- every lane's bundled example answer, replayed through the real render path.

**Metered (credits, sign-in required):** the four model lanes.

## The contract

Every lane returns one JSON object with the same outer envelope — `lane`, `posture`, `verdict`,
`runtime`, `actor_name`, `findings[]`, `coverage_check[]`, `artifact{}`, `next_lane{}` — and differs
only inside `body`. `posture` is `actor-ready`, `fix-first` or `not-actor-yet`. The full contract,
including what happens to unrecognised values, is documented at
https://apify-desk.skillsafe.ai/api.html

**Reader reconciliation.** Every flag the free reader raises is sent with the run, and the model must
return exactly one `coverage_check` entry for each. A flag with no entry is rendered as *not
accounted for* rather than quietly dropped — the free lane exists to hold the paid lane accountable.

## Grounding rules the model is held to

- Every claim must trace to a line of the pasted project. Missing facts go in `open_questions`.
- Never invent a URL, an Actor id, a token or a package version.
- Never emit a real credential; a token literal in the paste is a critical finding.
- The dataset field list starts from what the reader read out of the code. A type may be corrected,
  but only with a finding that says so. A field the code does not push may not be added.

## Sources

A derived work built on four Apify agent skills:

- `@apify/apify-actorization` — the `actorize` lane
- `@apify/apify-actor-development` — the `input` lane
- `@apify/apify-generate-output-schema` — the `output` lane
- `@apify/apify-sdk-integration` — the `client` lane

Not affiliated with, endorsed by, or operated by Apify. Apify Desk is published on SkillSafe
(https://skillsafe.ai/), which supplies the model, the metering and the account.

## Pages

- `/` — the app
- `/api.html` — the HTTP API in eight languages
- `/tokens.html` — token management (noindex, not in the sitemap)
- `/llms.txt` — this file