no key · no account · no server

Let your agent read the library.

The whole corpus is exposed as static JSON at /prompts/index.json, and the same catalog is served as JSON at /api/prompts. That is the entire integration. Any agent, script or one-line curl can read it — no API key to rotate, no account to create, no MCP server to stand up, no rate limit to babysit. If your tool can fetch a URL, it can already use this library.

Open /prompts/index.json Four-step setup Check the API health

332paste-ready prompts

2static JSON surfaces

0API keys required

MITlicense, everything

Setup

From zero to a generated page in four steps.

Nothing below installs anything, and nothing phones home. You fetch one file, you paste one string, and you judge the result with the same checks this library uses. Total time: about a minute.

Fetch the catalog

prompts/index.json is the complete agent-facing index: the full prompt_text for every prompt, plus its model, platform, token usage, acceptance criteria, verification transcript and cross-check verdict. It is a static file, so any HTTP client works — curl, fetch, requests, wget.

SITE="https://landingpageprompts.com"

# the complete agent-facing index: prompt_text + model + tokens + evidence
curl -s "$SITE/prompts/index.json" | head -40

# the same corpus through the JSON API, filtered and paged server-side
curl -s "$SITE/api/prompts?category=Hero%20Section&sort=cheap&limit=2"

Point Claude Code / Cursor / Codex at the folder

All three editors let you grant a workspace folder to their built-in agent. Clone or copy this repository, open that folder, and the agent can read prompts/index.json, the prompt docs in prompts/, the demo pages in public/demos/ and the token ledger in data/ like any other file. No plugin, no login, no MCP configuration block.

# 1. get the repo — clone your fork, or copy this folder
cd landingpageprompts

# 2. hand the folder to the agent that is already in your editor
claude          # Claude Code
codex           # Codex CLI

# Cursor: File → Open Folder → landingpageprompts/, then in the Agent panel:
#   "Read prompts/index.json and list every prompt with its model and token cost."

Paste a prompt's prompt_text into your editor agent

The prompt_text field is the exact string that was sent to the model which produced the verified demo. Hand it to your agent verbatim and let it build the page from scratch. Do not paraphrase: the prompts pin exact hex values, timings, DOM structure and a non-negotiable technical contract, and softening any of that is the fastest way to lose the effect.

# pull one prompt's full text out of the index with jq:
curl -s "$SITE/prompts/index.json" \
  | jq -r '.prompts[] | select(.slug == "magnetic-orbit") | .prompt_text'

# or, with the folder open in your editor, just ask the agent:
#   "Read prompts/index.json, take the prompt with slug 'neural-drift',
#    and run its prompt_text verbatim."

Verify the result yourself with the same checks the library uses

Each prompt's acceptance array lists the exact machine-checkable criteria our headless-Chromium harness runs, and verification.checks[] is the transcript from the run we published — 20 to 23 checks per demo, from window.__DEMO__ telemetry to horizontal-overflow probes at 390, 768 and 1440 px. Run your page, check them yourself, and compare. A prompt that passes on our model and fails on yours is still a useful data point: it says the prompt is model-sensitive.

# every prompt carries its own acceptance criteria, verbatim:
curl -s "$SITE/prompts/index.json" \
  | jq -r '.prompts[] | select(.slug == "scroll-atlas") | .acceptance[]'

# and the full headless-Chromium transcript from the run we published:
curl -s "$SITE/prompts/index.json" \
  | jq -r '.prompts[] | select(.slug == "scroll-atlas")
           | .verification.checks[] | "\(if .pass then "PASS" else "FAIL" end)\t\(.name)\t\(.detail)"'

Schema

What is inside prompts[].

The index is one JSON object — name, version, license, how_to_use, generated_at, a totals block and the prompts array. These are the fields of each entry, in the order you will meet them.

Field	Type	Description
slug	string	Stable id, and the demo folder name — liquid-glass-voyage, scroll-atlas, magnetic-orbit, neural-drift, kinetic-type, stack-deck.
title	string	Human title, e.g. “Liquid Glass Voyage”. Use it for link text and list labels.
category	string	Coarse grouping for filtering: “Hero Section” or “Landing Page”.
effect	string	One sentence describing the motion this prompt produces, e.g. “Cursor-reactive magnetic hero with spotlight, tilt and a custom cursor.”
platform	string	Which wire API ran the build — workbuddy (OpenAI chat-completions) or cmdcode (Anthropic messages). You never need it to use a prompt.
platform_label	string	The human name for that platform: “Workbuddy proxy” or “cmd-code”.
platform_url	string	The endpoint the build request was sent to, so a run can be replayed on the same wire format.
model	string	The exact model id that produced the verified demo — hy4-preview-f, MiniMaxAI/MiniMax-M3, glm-5.3, kimi-k3, gemini-3.5-flash, gpt-5.5.
model_label	string	That model's display name as the provider writes it, e.g. “GLM-5.3 (glm-5.3)”.
prompt_text	string	The complete, paste-ready prompt — the exact string sent to the model, with no marketing wrapper. This is the field you hand to your agent, verbatim.
demo	string	Path to the generated, verified demo page, e.g. /demos/scroll-atlas/index.html. Open it to see what the prompt actually produced.
doc	string	Path to the published Markdown doc for the prompt, verification block included, e.g. /prompts/scroll-atlas.md.
acceptance	string[]	That prompt's own acceptance criteria — 14 to 15 machine-checkable statements, one per harness check. Read it before you build, and re-check your output against it after.
usage	object	Exact token accounting for the generation run: build, repair, cross-check and wasted totals, plus prompt / completion / reasoning splits, call count and latency in ms.
verification	object	The headless-Chromium transcript: passed, passed_checks, total_checks and a checks[] array with a pass flag and an observed detail line per check. null when a prompt has not been verified.
crosscheck	object	An independent reviewer's verdict — always a different model than the builder: verdict, confidence, aesthetic_score, summary, requirements met and missed, and the issues it raised.

Every entry in prompts[] is complete on its own: fetch the index once and you have the prompt text, the exact model that ran it, its token cost and its test results without a second request. The first entry today is Liquid Glass Voyage — 1,169 words of prompt text, built by hy4-preview-f.

Runnable

A complete example in 25 lines of Node.

This is the whole integration: fetch the index, pick a random prompt, print its prompt_text. It runs on any Node 18+ with zero dependencies, because fetch is built in. Save it as pick.mjs, run node pick.mjs, and pipe the output wherever you like.

pick.mjs — fetch the index, pick one prompt at randomDownload prompts/index.json

// pick.mjs — fetch the LandingPagePrompts prompt index and print one prompt at random.
// Node 18+ with zero dependencies: fetch() is built in.
const BASE = process.env.LANDINGPAGEPROMPTS_BASE ?? "https://landingpageprompts.com";

const res = await fetch(`${BASE}/prompts/index.json`);
if (!res.ok) throw new Error(`index fetch failed: ${res.status}`);

const index = await res.json();
if (!Array.isArray(index.prompts) || index.prompts.length === 0) {
  throw new Error("no prompts found in the index");
}

const pick = index.prompts[Math.floor(Math.random() * index.prompts.length)];

console.log(`# ${pick.title} (${pick.category})`);
console.log(`# model:    ${pick.model} on ${pick.platform_label}`);
console.log(`# demo:     ${pick.demo}`);
console.log(
  `# verified: ${
    pick.verification
      ? `${pick.verification.passed_checks}/${pick.verification.total_checks} checks passed`
      : "not yet verified"
  }\n`
);
console.log(pick.prompt_text);

Select the snippet and copy it — this page ships no client JavaScript, on purpose. Running it against a local dev server? Start the site first (pnpm dev) or point LANDINGPAGEPROMPTS_BASE at your deployed Worker. The header lines are printed with a leading #, so you can redirect the whole output into a file and it stays a valid prompt.

Honest tradeoffs

Why not an MCP server?

We considered shipping one. It would have been the conventional answer, and it would have turned a free library into a paid chokepoint waiting to happen. Three reasons we chose a static file instead:

A static file is cacheable, auditable and free.
prompts/index.json is bytes on disk. A CDN can cache it indefinitely, you can curl it into a file and diff it against last week's copy, and serving it costs nothing. There is no process to keep alive and nothing to go down at 2am.
An MCP server is a paid chokepoint and a single point of failure.
Every hosted MCP server means someone else's rate limit, someone else's uptime and eventually someone else's invoice. A library of 332 prompts does not need a standing service — and the moment a free MCP server gets popular, it is the first thing that gets metered. Your agent should not need our permission slip to read a static JSON file.
JSON works with every tool today, including tools that will never support MCP.
MCP is a young protocol; JSON is thirty years old and understood by every agent, shell script, notebook and language runtime in existence. Claude Code, Cursor, Codex, a cron job, a Makefile — if it can fetch a URL, it is already integrated. When MCP is as universal as JSON, anyone can wrap this file in a server, including you.

Get prompts/index.json Read how prompts are verified See the raw token ledger

Live API

The same data, over HTTP.

The static file is the recommended path for agents. These endpoints exist for everything a file cannot do: filtering, search, counters and writes. All of them degrade to the bundled catalog when a binding is absent, so none of them can 500 because Cloudflare is having a bad day.

GET/api/prompts

The catalog with server-side filtering, sorting and paging: ?category=, ?model=, ?q=, ?sort=featured|verified|cheap|az, ?limit=, ?offset=. Reads from D1 when the binding is live, from the bundled catalog otherwise — the response shape is identical either way.

GET/api/prompts/[slug]

One prompt in full, including its prompt_text, acceptance list, verification transcript and cross-check verdict, plus its live copy and view counters.

GET/api/search?q=

Full-text search over title, effect, category and prompt text, backed by D1's FTS5 index. Add &mode=semantic for Workers AI embeddings through Vectorize.

GET/api/ledger

Every model call behind this library with its exact token usage, read from the D1 ledger mirror.

GET/api/stats

The same rollups the /stats page renders: totals, ledger by tag, the Durable Object counter mirror and the product-event counts.

GET/api/health

Binding-by-binding health check — which Cloudflare products are live in this request and which are absent.

POST/api/verify

Queues one demo for re-verification in headless Chromium. Rate limited, and idempotent per slug while a run is in flight.

POST/api/copy

Records a real copy of a prompt against its slug and returns the updated Durable Object counter.

POST/api/request

The prompt-request intake endpoint, rate limited and gated by Turnstile. It fails closed: with no TURNSTILE_SECRET it answers 503 rather than accepting anonymous submissions. No public form is wired to it yet.