Building an AI App on the Wikiprompt Dataset

Building an AI App on the Wikiprompt Dataset

Every indie hacker who has tried to build a "prompt library" app hits the same wall on day one: you need seed content, and scraping is slow, brittle, and rude to whoever's server you're hitting. Wikiprompt just removed that wall. The whole catalog, over 55,000 prompts spanning ChatGPT, Claude, Gemini, Midjourney, GPT Image, Veo, Kling, Seedance, Nano Banana, Grok and more, is now available as a public bulk dataset. No key, no rate-limit dance, no scraping. Just JSON.

This post is a build log, not a press release. Four small apps you could ship this weekend, and the exact plumbing to get there.

What you're actually working with

Hit the manifest first:

curl "https://www.wikiprompt.org/dataset"

It returns total_prompts, the record_fields you can expect on every row, and the pagination scheme. The real data lives at /dataset/prompts, paginated with a keyset cursor: each page hands you a next URL, you follow it until next comes back null. Up to 500 records per page.

curl "https://www.wikiprompt.org/dataset/prompts?limit=500"

Each record is a small, useful object: slug, url, title, description, content (the actual prompt text you'd paste into a model), category, tags, media (image/video URLs when the prompt produced one), model (what it was built for or run on), metadata (structured fields like media type, aspect ratio, style, and a quality assessment), author, original_source (the original tweet or post it came from), and timestamps. That's enough to build a real UI without a single extra API call.

Here's the full ingest loop in Python, maybe 15 lines to a local SQLite cache:

import requests, sqlite3

db = sqlite3.connect("wikiprompt.db")

db.execute("""create table if not exists prompts(

slug text primary key, title text, description text,

content text, category text, model text, url text)""")

url = "https://www.wikiprompt.org/dataset/prompts?limit=500"

while url:

data = requests.get(url).json()

for p in data["records"]:

db.execute(

"insert or replace into prompts values (?,?,?,?,?,?,?)",

(p["slug"], p["title"], p["description"],

p["content"], p["category"], p.get("model"), p["url"]),

)

db.commit()

url = data.get("next")

Run that once, and you have a local, queryable copy of the whole catalog. CORS is wide open (Access-Control-Allow-Origin: *) and responses are edge-cached, so this is friendly to run from a browser too, not just a backend job.

Four things worth building

A prompt-search UI. The dataset gives you category, tags, model and metadata for free, which means faceted search is basically a SQL WHERE clause away: "Midjourney prompts tagged portrait" or "coding prompts for Claude" resolve to a filter, not a research project. If you don't want to build the index yourself, wikiprompt already runs one: the search API takes ?q= and returns ranked JSON, good enough to prototype a search box before you've written a single line of retrieval code.

A "prompt of the day" bot. Cron job, pick a random row from your local cache (or filter by category=creative for a themed feed), post title + content + the url back to origin. The media field means you can attach the actual output image or video to the post, not just text. This is maybe 40 lines of code and works equally well as a Slack bot, a Telegram bot, or a cron that posts to X.

A browser extension. Right-click any text field, "insert a prompt," search your local cache by category or model, paste content in. Since the data is local after the initial sync, this works offline and instantly, no network round-trip per keystroke.

A Discord bot. /prompt image midjourney slash command, filter your cache by category and model, reply with title, content, and the media as an embed. If someone wants to see the original, link original_source in the footer, that's the attribution covered in the same message.

Using the metadata field for real

metadata is where the interesting stuff lives for anything media-related: aspect ratio, style tags, a quality assessment. If you're building something that ranks or recommends prompts (rather than just listing them), this is your signal. A "best Midjourney prompts for portraits, 3:4 aspect ratio, high quality score" filter is a couple of extra WHERE clauses once you've ingested the field, no separate scoring pipeline required.

For a taste of what a good prompt record looks like end to end, browse a few live pages: a data physicalization image prompt, a futuristic arachnid character transformation, and a mysterious nomadic traveler character design. Each of those is a full record in the dataset too, same fields, same content you'd copy into a model.

Attribution isn't optional, and it's not hard either

Wikiprompt aggregates prompts from public posts by their original authors; it isn't the license-holder, it's the librarian. If your app surfaces a prompt, show original_source alongside it and credit wikiprompt.org as where you got the catalog. That's the deal, and the dataset makes it trivial to honor since original_source is already sitting right there in every record. Don't strip it out during ingestion just because your schema doesn't have a column for it yet.

If you'd rather not run your own index

Three options exist depending on how much infrastructure you want to own. Run the bulk dataset through your own search/recommendation layer if you want full control. Call the search API directly if you just need results, not a pipeline. Or, if you're building an agent rather than an app, point it at the MCP server, which exposes search, categories, and individual prompts as tools Claude and other agents can call natively. There's also llms.txt if you want a model to understand the whole surface area in one fetch.

Start here

curl "https://www.wikiprompt.org/dataset/prompts?limit=500" | head -c 2000

Look at what comes back, pick one of the four ideas above, and you'll have something working before the coffee's cold. The hard part, 55,000+ curated prompts across a dozen models, is already done. What you build with it is the fun part.