Trivia API for vibe coders

Why this exists

What you will build

The stack — opinionated and boring

• Vite — instant dev server, zero config, build for production with pnpm build.
• React 19 — useState and useEffect are all you need; no useReducer, no Redux, no Zustand.
• TypeScript — pays for itself the first time an LLM hallucinates a field name; the compiler catches it.
• QuizBase API — REST endpoint, single header for auth (X-API-Key), response shape stable since v1.
• No backend — Publishable keys (qb_pk_…) are CORS-safe and can live in your client bundle. Secret keys (qb_sk_…) are server-only.

Build it step-by-step

Six steps, ten minutes. Each step is a paragraph of reasoning followed by code you can paste. No code is hidden, no dependency is unexplained, no step says "and then magic happens". If you get stuck, jump to the pitfalls section below.

1. Step 1
   Create the Vite + React + TypeScript app

   Spin up a fresh project. The `react-ts` template gives you React 19, TypeScript strict mode, and Vite preconfigured. You will be in dev mode in fewer keystrokes than it takes to read this paragraph.

   bash

   pnpm create vite@latest quiz-app -- --template react-ts
   cd quiz-app
   pnpm install

2. Step 2
   Get your free QuizBase API key

   Sign up at quizbase.runriva.com/pricing — pick the free tier (no card, 500 requests per day, every endpoint unlocked). After signup, your dashboard has a 'Create key' button. Pick a **publishable key** (prefix `qb_pk_…`, dashboard scope label `publishable`) — publishable keys are CORS-safe and meant for browser code. Copy it once (it is shown in plaintext exactly once for security reasons), then drop it into a new `.env.local` file at the root of your Vite app.

   bash

   VITE_QUIZBASE_KEY=qb_pk_your_key_here

3. Step 3
   Fetch your first question

   Open `src/App.tsx` and replace its contents with a single `useEffect` that fires once on mount. We hit `/v1/questions` with three filters — category, language, limit — and the publishable key in the `X-API-Key` header. Response is JSON; `data[0]` is your question with `text`, `correctAnswer`, and `incorrectAnswers` as separate fields.

   tsx

   import { useEffect, useState } from 'react';
   
   interface Question {
     id: string;
     text: string;
     correctAnswer: string;
     incorrectAnswers: string[];
   }
   
   export default function App() {
     const [question, setQuestion] = useState<Question | null>(null);
   
     useEffect(() => {
       fetch(
         'https://quizbase.runriva.com/api/v1/questions' +
           '?category=science-and-nature&lang=en&limit=1',
         { headers: { 'X-API-Key': import.meta.env.VITE_QUIZBASE_KEY } }
       )
         .then((r) => r.json())
         .then((d) => setQuestion(d.data[0]));
     }, []);
   
     if (!question) return <p>Loading…</p>;
     return <h1>{question.text}</h1>;
   }

4. Step 4
   Render the four answer choices

   The API returns `correctAnswer` and `incorrectAnswers` separately so you can decide whether to shuffle. For a quiz we want them mixed — otherwise the correct answer is always last and the game is solved. A `useMemo` keyed on `question.id` shuffles once per question and remembers the order through re-renders.

   tsx

   import { useEffect, useMemo, useState } from 'react';
   
   // …
   
   const choices = useMemo(() => {
     if (!question) return [];
     return [question.correctAnswer, ...question.incorrectAnswers]
       .map((value) => ({ value, sort: Math.random() }))
       .sort((a, b) => a.sort - b.sort)
       .map(({ value }) => value);
   }, [question?.id]);
   
   // JSX
   return (
     <main style={{ maxWidth: 600, margin: '2rem auto', fontFamily: 'system-ui' }}>
       <h1>{question.text}</h1>
       <ul style={{ listStyle: 'none', padding: 0 }}>
         {choices.map((c) => (
           <li key={c} style={{ margin: '0.5rem 0' }}>
             <button style={{ padding: '0.5rem 1rem', width: '100%' }}>{c}</button>
           </li>
         ))}
       </ul>
     </main>
   );

5. Step 5
   Handle answers — correct or wrong

   Track which choice the user clicked. Compare to `question.correctAnswer`. Show a banner. Disable the buttons after answering — nobody wants to second-guess once they have committed. This is the smallest amount of state that makes the app feel like a real quiz.

   tsx

   const [selected, setSelected] = useState<string | null>(null);
   const isCorrect = selected === question.correctAnswer;
   
   return (
     <main style={{ maxWidth: 600, margin: '2rem auto', fontFamily: 'system-ui' }}>
       <h1>{question.text}</h1>
       <ul style={{ listStyle: 'none', padding: 0 }}>
         {choices.map((c) => (
           <li key={c} style={{ margin: '0.5rem 0' }}>
             <button
               disabled={selected !== null}
               onClick={() => setSelected(c)}
               style={{
                 padding: '0.5rem 1rem',
                 width: '100%',
                 background:
                   selected === c ? (isCorrect ? '#c8f7c5' : '#f7c5c5') : undefined
               }}
             >
               {c}
             </button>
           </li>
         ))}
       </ul>
       {selected && (
         <p>
           {isCorrect
             ? '✓ Correct!'
             : `✗ Wrong — the answer was ${question.correctAnswer}.`}
         </p>
       )}
     </main>
   );

6. Step 6
   Add a Next button and ship to production

   Wrap the fetch in a function, call it on mount and on 'Next question' click, reset the `selected` state when a new question arrives. Then build (`pnpm build`) and drag the `dist/` folder onto Vercel, Netlify, or Cloudflare Pages. The whole app is static — no server, no environment beyond the build-time injected `VITE_QUIZBASE_KEY`.

   bash

   pnpm build
   # dist/ is your deployable folder — drag it to vercel.com, netlify.com, or pages.cloudflare.com

The complete app — one file, copy-paste ready

If you skipped the walkthrough and just want the finished thing, here is the whole `src/App.tsx`. Drop it in, add `VITE_QUIZBASE_KEY` to `.env.local`, run `pnpm dev`.

import { useEffect, useMemo, useState } from 'react';

interface Question {
  id: string;
  text: string;
  correctAnswer: string;
  incorrectAnswers: string[];
}

const API = 'https://quizbase.runriva.com/api/v1/questions';
const KEY = import.meta.env.VITE_QUIZBASE_KEY;

async function fetchQuestion(): Promise<Question> {
  const r = await fetch(`${API}?category=science-and-nature&lang=en&limit=1`, {
    headers: { 'X-API-Key': KEY }
  });
  const d = await r.json();
  return d.data[0];
}

export default function App() {
  const [question, setQuestion] = useState<Question | null>(null);
  const [selected, setSelected] = useState<string | null>(null);

  useEffect(() => {
    void fetchQuestion().then(setQuestion);
  }, []);

  const choices = useMemo(() => {
    if (!question) return [];
    return [question.correctAnswer, ...question.incorrectAnswers]
      .map((value) => ({ value, sort: Math.random() }))
      .sort((a, b) => a.sort - b.sort)
      .map(({ value }) => value);
  }, [question?.id]);

  if (!question) return <p>Loading…</p>;
  const isCorrect = selected === question.correctAnswer;

  return (
    <main style={{ maxWidth: 600, margin: '2rem auto', fontFamily: 'system-ui' }}>
      <h1>{question.text}</h1>
      <ul style={{ listStyle: 'none', padding: 0 }}>
        {choices.map((c) => (
          <li key={c} style={{ margin: '0.5rem 0' }}>
            <button
              disabled={selected !== null}
              onClick={() => setSelected(c)}
              style={{
                padding: '0.5rem 1rem',
                width: '100%',
                background:
                  selected === c ? (isCorrect ? '#c8f7c5' : '#f7c5c5') : undefined
              }}
            >
              {c}
            </button>
          </li>
        ))}
      </ul>
      {selected && (
        <p>
          {isCorrect
            ? '✓ Correct!'
            : `✗ Wrong — the answer was ${question.correctAnswer}.`}
        </p>
      )}
      <button
        onClick={() => {
          setSelected(null);
          void fetchQuestion().then(setQuestion);
        }}
        style={{ marginTop: '1rem', padding: '0.5rem 1rem' }}
      >
        Next question
      </button>
    </main>
  );
}

Get your free API key at /pricing — no credit card.

Let the AI write it — Cursor, Claude Code, Copilot

You are a vibe coder. Of course you want the AI to write this. Here are three prompts you can paste into Cursor, Claude Code, or GitHub Copilot — each produces a working app in under two minutes. The prompts include the exact API response shape, which is the difference between code that works on the first try and code that hallucinates `question.options` instead of `question.incorrectAnswers`.

Build a trivia quiz app using the QuizBase API.

Stack: React + TypeScript + Vite. One component in src/App.tsx. No router, no state library, no styling framework — inline styles are fine.

API call:
  GET https://quizbase.runriva.com/api/v1/questions?category=science-and-nature&lang=en&limit=1
  Header: X-API-Key: <value from import.meta.env.VITE_QUIZBASE_KEY>

Response shape:
{
  "data": [{
    "id": "uuid",
    "text": "What is...?",
    "correctAnswer": "Answer",
    "incorrectAnswers": ["Wrong 1", "Wrong 2", "Wrong 3"]
  }]
}

Requirements:
1. Fetch one question on mount (useEffect).
2. Render the question and four answer choices as buttons (shuffle correct + incorrect with useMemo keyed on question.id).
3. Click a button → highlight it green if correct, red if wrong; show "Correct!" or "Wrong — the answer was X" below.
4. Disable all buttons after one is clicked.
5. Show a "Next question" button that fetches a new question and resets selection.
6. Loading state ("Loading…") before the first question arrives.

Use TypeScript types for the Question shape. No external deps beyond React.

Build a trivia quiz app using the QuizBase API.

Stack: React + TypeScript + Vite. One component in src/App.tsx. No router, no state library, no styling framework — inline styles are fine.

API call:
  GET https://quizbase.runriva.com/api/v1/questions?category=science-and-nature&lang=en&limit=1
  Header: X-API-Key: <value from import.meta.env.VITE_QUIZBASE_KEY>

Response shape:
{
  "data": [{
    "id": "uuid",
    "text": "What is...?",
    "correctAnswer": "Answer",
    "incorrectAnswers": ["Wrong 1", "Wrong 2", "Wrong 3"]
  }]
}

Requirements:
1. Fetch one question on mount (useEffect).
2. Render the question and four answer choices as buttons (shuffle correct + incorrect with useMemo keyed on question.id).
3. Click a button → highlight it green if correct, red if wrong; show "Correct!" or "Wrong — the answer was X" below.
4. Disable all buttons after one is clicked.
5. Show a "Next question" button that fetches a new question and resets selection.
6. Loading state ("Loading…") before the first question arrives.

Use TypeScript types for the Question shape. No external deps beyond React.

// Trivia quiz app powered by the QuizBase API
// API: GET https://quizbase.runriva.com/api/v1/questions?category=science-and-nature&lang=en&limit=1
// Auth: X-API-Key header from import.meta.env.VITE_QUIZBASE_KEY
// Response shape: { data: [{ id, text, correctAnswer, incorrectAnswers: string[] }] }
//
// Requirements:
// - Fetch question on mount with useEffect
// - Shuffle correctAnswer + incorrectAnswers into four buttons (useMemo keyed on question.id)
// - On click: highlight correct=green / wrong=red, disable buttons, show feedback text
// - "Next question" button refetches and resets selection
// - Loading state before first question
import { useEffect, useMemo, useState } from 'react';

interface Question {
  id: string;
  text: string;
  correctAnswer: string;
  incorrectAnswers: string[];
}

export default function App() {
  // Press Tab and let Copilot write the rest
}

Skip the code entirely — connect via MCP

You can also skip the REST API and let your AI assistant talk to QuizBase directly via the Model Context Protocol. The MCP server at `https://quizbase.runriva.com/mcp` exposes ten typed tools — your AI sees them as native capabilities, with full schema and response shape upfront. No fetch boilerplate, no field-name hallucinations, no client SDK to keep in sync.

• Zero code to write — your AI assistant gets quizbase_random, quizbase_list, quizbase_question_by_id and seven more tools as native capabilities.
• No more "but the LLM hallucinated my field names" — the MCP server tells the AI the exact tool schema, parameters, and response shape upfront.
• Same key, same free tier — your qb_pk_… works for MCP and REST identically. One quota, one place to rotate.
• Works alongside REST — connect MCP for ideation and prototyping in Cursor, ship the actual app with REST when you are ready for production.

{
  "mcpServers": {
    "quizbase": {
      "url": "https://quizbase.runriva.com/mcp",
      "headers": {
        "Authorization": "Bearer qb_pk_your_key_here"
      }
    }
  }
}

claude mcp add quizbase \
  --transport http \
  --url https://quizbase.runriva.com/mcp \
  --header "Authorization: Bearer qb_pk_your_key_here"

# verify
claude mcp list

Name:    QuizBase
URL:     https://quizbase.runriva.com/mcp
Auth:    Bearer token
Token:   qb_pk_your_key_here

Want to test before configuring anything? /playground/mcp is our interactive MCP tester — paste your key, see all ten tools, run them with form inputs, copy the JSON.

See it ship

Other stacks — same API, same idea

Vite + React is the easiest starting point but it is not the only one. The QuizBase API call is identical across runtimes — only the rendering layer changes. Here are three more variants you can copy.

// app/page.tsx
import { revalidatePath } from 'next/cache';

async function fetchQuestion() {
  const r = await fetch(
    'https://quizbase.runriva.com/api/v1/questions?category=science-and-nature&lang=en&limit=1',
    {
      headers: { 'X-API-Key': process.env.QUIZBASE_SECRET_KEY! },
      cache: 'no-store' // fresh question every request
    }
  );
  return (await r.json()).data[0];
}

export default async function Page() {
  const q = await fetchQuestion();
  return (
    <main>
      <h1>{q.text}</h1>
      <ul>
        {[q.correctAnswer, ...q.incorrectAnswers].map((c) => (
          <li key={c}>{c}</li>
        ))}
      </ul>
      <form action={async () => { 'use server'; revalidatePath('/'); }}>
        <button type="submit">Next question</button>
      </form>
    </main>
  );
}

<!doctype html>
<html lang="en">
<body>
  <main id="app">Loading…</main>
  <script>
    const KEY = 'qb_pk_your_key_here'; // publishable key — CORS-safe in browser
    async function load() {
      const r = await fetch(
        'https://quizbase.runriva.com/api/v1/questions?lang=en&limit=1',
        { headers: { 'X-API-Key': KEY } }
      );
      const q = (await r.json()).data[0];
      const choices = [q.correctAnswer, ...q.incorrectAnswers]
        .sort(() => Math.random() - 0.5);
      document.getElementById('app').innerHTML = `
        <h1>${q.text}</h1>
        ${choices.map((c) => `<button data-c="${c}">${c}</button>`).join('')}
        <p id="feedback"></p>
        <button id="next">Next</button>
      `;
      document.querySelectorAll('[data-c]').forEach((b) => {
        b.onclick = () => {
          const correct = b.dataset.c === q.correctAnswer;
          document.getElementById('feedback').textContent = correct
            ? '✓ Correct!' : '✗ Wrong — answer was ' + q.correctAnswer;
        };
      });
      document.getElementById('next').onclick = load;
    }
    load();
  </script>
</body>
</html>

import { useEffect, useState } from 'react';
import { Button, FlatList, Text, View } from 'react-native';

export default function App() {
  const [q, setQ] = useState<any>(null);

  useEffect(() => {
    fetch(
      'https://quizbase.runriva.com/api/v1/questions?category=science-and-nature&lang=en&limit=1',
      { headers: { 'X-API-Key': process.env.EXPO_PUBLIC_QUIZBASE_KEY! } }
    )
      .then((r) => r.json())
      .then((d) => setQ(d.data[0]));
  }, []);

  if (!q) return <Text>Loading…</Text>;
  const choices = [q.correctAnswer, ...q.incorrectAnswers]
    .sort(() => Math.random() - 0.5);

  return (
    <View style={{ padding: 24, marginTop: 48 }}>
      <Text style={{ fontSize: 20, marginBottom: 16 }}>{q.text}</Text>
      <FlatList
        data={choices}
        keyExtractor={(c) => c}
        renderItem={({ item }) => (
          <Button
            title={item}
            onPress={() =>
              alert(item === q.correctAnswer ? 'Correct!' : 'Wrong')
            }
          />
        )}
      />
    </View>
  );
}

Pitfalls — things that will trip you up

Six gotchas we see in real support requests, with the actual fix. If you hit one, this section saves you fifteen minutes of Googling.

• CORS errors when I deploy to production.

  You are probably using a secret key (qb_sk_…) in the browser — those are deliberately not CORS-safe. Publishable keys (qb_pk_…) work from any origin and are designed for client-side code. Swap the key in your env var, redeploy.

• "No questions matched" — empty `data` array.

  Your filter combination is too narrow. Common offender: a small category combined with a small language. Drop one filter (try ?lang=en only) to verify, then add filters back one at a time. The /v1/questions/random endpoint never returns empty for valid filters.

• Rate limit hit (HTTP 429) during development.

  Free tier is 500 requests per day per account. If you are hot-reloading on every keystroke, useEffect may be firing fifty times per minute. Cache the question in state (you already do), and use ?limit=10 plus a client-side pointer instead of one fetch per question. The 429 response includes a Retry-After header — honor it.

• I accidentally committed my API key to git.

  Rotate it immediately in the dashboard (the old key is revoked and a new one issued). Then: .env* should be in .gitignore (Vite adds this automatically; double-check). For team projects, use .env.example with placeholder values committed instead of real ones.

• TypeScript complains about `import.meta.env.VITE_QUIZBASE_KEY` being `string | undefined`.

  It is — Vite cannot prove the env var exists at build time. Either non-null-assert (!) if you have a build-time check, or add a src/vite-env.d.ts with interface ImportMetaEnv { readonly VITE_QUIZBASE_KEY: string }. The official TypeScript SDK (@quizbase/sdk, npm) ships with the response shape typed so you do not need to define Question manually.

• My Cursor / Claude Code prompt produced code that does not compile.

  Usually the AI invented a field name (question.options instead of question.choices, or data.question instead of data[0]). Paste the response shape from the prompt block above into the same chat and ask it to fix. Or paste the failing error message — both Cursor and Claude Code are good at self-correction when you give them the compiler output.

Frequently asked questions

Do I really need zero backend?

Yes for development and weekend projects — publishable keys (`qb_pk_…`, dashboard scope label `publishable`) are CORS-safe by design and meant to live in client-side code. For production you have a choice: keep using publishable keys client-side (simple, rate-limited per account, anyone can read them from DevTools but they cannot do more than your tier allows) or switch to secret keys (`qb_sk_…`) behind a tiny serverless proxy if you want to hide your usage patterns from prying eyes. Either is fully supported.

Is the free tier really free, with no credit card?

Yes. 500 requests per day, forever, no card on file, no trial countdown. The free tier exists because we want you to try the API end-to-end before paying. When you ship to production and need higher limits, paid tiers start at a price designed for solo developers — see the pricing page for exact numbers.

Can I deploy this to Vercel, Netlify, or Cloudflare Pages?

Yes. Run `pnpm build` and drag the resulting `dist/` folder onto any of the three. The QuizBase key is injected at build time (`VITE_QUIZBASE_KEY`), so you set it in the host dashboard as a build-time environment variable — the rest is static HTML, CSS, and JavaScript.

How many languages are supported?

Twenty-plus actively maintained. You can list them with `GET /v1/languages` — the response is a JSON array of language codes plus a count of quiz-ready questions per code. To switch your app's language, change the `?lang=` parameter (`en`, `pl`, `es`, `de`, `fr`, `it`, `ja`, `pt`, and so on).

How accurate are the questions?

Each question carries a full `attribution` object — `source` (which upstream dataset: OpenTDB, OpenTriviaQA, MKQA), `author`, `license`, and `modifications`. We curate, deduplicate, and translate; we do not generate questions with an LLM. If you spot a wrong answer, every question has a /report endpoint and a `Report` link on the dashboard.

Why not just use ChatGPT or Claude to generate questions?

Three problems. (1) LLMs hallucinate — answers that look right but are wrong, especially on dates, biology, and edge-case trivia. (2) Difficulty is inconsistent — the same prompt produces wildly different challenges across runs. (3) No attribution chain — you cannot tell users where a fact came from. QuizBase questions trace back to a real source dataset with a known license.

Can I filter by tags, subcategories, or topics?

Yes. Beyond the 24 top-level categories, every question has tags (proper nouns: `python`, `napoleon`, `dna`) and subcategories (broader groupings: `european-capitals`, `cellular-biology`). Filter with `?tags=python`, `?subcategory=european-capitals`, or `?topics_any=programming,linguistics` to get questions from any of multiple topics.

Can my AI agent (Claude Desktop, Cursor, ChatGPT) use QuizBase?

Yes — and as a vibe coder you might want to skip the REST API entirely and use MCP instead. We ship a Model Context Protocol server at `https://quizbase.runriva.com/mcp` (Streamable HTTP). Add it to Cursor, Claude Code, or Claude Desktop and your AI gets ten trivia tools (`quizbase_random`, `quizbase_list`, `quizbase_question_by_id`, `quizbase_topics` and seven more) as native capabilities — no fetch, no API shape guessing, no client SDK. See the MCP section above for one-snippet setup per client. There is also `/.well-known/mcp` for auto-discovery and `/openapi.json` for ChatGPT Custom GPT actions.

Is commercial use allowed?

Yes. The API is commercially licensed per your subscription tier. The underlying dataset (the BY-SA dump downloadable from /data) is Creative Commons Attribution-ShareAlike 4.0 — free for any use including commercial, with attribution. Each question response also includes a per-row `attribution.license` field so you can comply with upstream sources without reading a single page of legal text.

Where do I get help if something breaks?

Docs at quizbase.runriva.com/docs, including a quickstart, full API reference, SDK guides, and troubleshooting. For API or platform bugs, use the in-dashboard "Report a problem" button — it auto-attaches your request_id, endpoint, and Sentry breadcrumbs, so triage is fast. The same button is on every error page. Not logged in? "Report a bug" link in the page footer opens an email draft. SDK-specific bugs go to github.com/maciejdzierzek/quizbase-sdk-ts. Content bugs in a question (wrong answer, bad translation) use POST /api/v1/report or the quizbase_report MCP tool. Status page at /status if you suspect an outage. Average response time is under 48 hours during the week.

Ten things to build next — pick one, ship it this weekend

You have the basic quiz. Here are ten directions you could take it — each small enough to ship in a weekend, each different enough that the resulting app is its own thing. Half of them, your AI can scaffold for you in fifteen minutes if you paste this idea into Cursor and ask.

1. 1. Daily challenge mode

   Show every visitor the same five questions today, a different five tomorrow. Use the date as a seed — same date, same questions for everyone, perfect for a 'compete with friends' angle. Two-line change: derive a deterministic seed from the date and pass it to `?seed=` (or use `quizbase_random` with a fixed cursor).

2. 2. Time pressure mode

   Add a five-second timer per question. Auto-submit on timeout. Score the streak — three wrong in a row resets your run. The mechanic that makes trivia apps actually addictive instead of "play once and forget".

3. 3. Language gauntlet

   Ask the user to pick three languages. Round one in English, round two in their first pick, round three in their second pick, round four in the third. Same question difficulty across languages — proves your app handles real i18n, not just "we support locales".

4. 4. Topic deep-dive

   Let the user type a topic (e.g. "biology", "napoleon", "python"). Use `?tags=` or `?topics_any=` to filter the question pool. Now it is not "general trivia" — it is "biology trivia for med students" or "napoleon trivia for the history nerd in your life".

5. 5. Slack / Discord bot

   Two-question-per-day bot for a community channel. Post the question at 10am, reveal the answer at 6pm, track who answered first. Twenty lines of Node + the Slack/Discord SDK + QuizBase API.

6. 6. Quiz lead-gen widget

   Embed a five-question quiz on your SaaS landing page. After answering, ask for email to "see how you compare". Industry: 5-10× higher conversion than "subscribe to our newsletter" CTAs. Build it as a `<script>` snippet others can drop into their own site.

7. 7. Anki flashcards generator

   Fetch 50 questions in a category, export as Anki .apkg (or CSV for Quizlet). One button, one download. The /data BY-SA dump is also an option if you want offline bulk export instead of API calls.

8. 8. Multiplayer real-time

   Two players, same question shown to both, first to click correct wins the round. Use a tiny WebSocket server (or Pusher / Ably / Liveblocks free tier) to sync. The complexity is the realtime layer, not the trivia — that part you already have.

9. 9. Daily email digest

   Five trivia questions in an email, every morning, on a topic the subscriber picked. Resend or Postmark free tier handles delivery. Reading time: 90 seconds. Retention metric people actually open.

10. 10. Voice quiz (Alexa / mobile)

    Wrap the API in a voice skill. "Hey Alexa, ask QuizBase for a science question." Response via speech synthesis. Doable in an afternoon if you have ever shipped an Alexa skill before — the trivia content is the easy part.

What to build next

You have a working quiz app. Here is where to go from here — each link is a concrete next step, not a vague "explore our docs".

• Add a multi-round game with score tracking →

  Turn the single-question demo into a 10-round game with a running score. Step-by-step guide.

• Switch the question language at runtime →

  Let players pick from 20+ languages with a dropdown. One extra fetch, one extra state.

• Connect a Claude or Cursor agent via MCP →

  Skip the REST layer entirely. Your AI assistant gets `quizbase_random` and `quizbase_list` as native tools.

• Browse the full API reference →

  Every filter, every parameter, every response field — with examples.

• Install the TypeScript SDK for first-class types →

  Skip the manual `interface Question`. Get autocomplete on every field, every response, every error code.