JAMB question database JSON

If you're building a JAMB CBT app, storing questions in JSON is one of the simplest ways to make the data usable by software.

A PDF is designed for reading. JSON is designed for applications.

With a proper JAMB question database JSON, your software can identify the question, options, correct answer, solution, examination year and other information without first extracting it from a document.

For developers who don't want to manually create that database, SdashAPI provides UTME/JAMB question data as structured JSON through its REST API. Its current coverage page reports 22 UTME subjects across an overall 1988–2026 range. SdashAPI

What should JAMB question JSON look like?

A useful record shouldn't look like this:

{
  "question": "What is the answer?",
  "answer": "B"
}

That might work for a tiny quiz, but it becomes limiting very quickly.

SdashAPI's actual V1 response structure includes fields such as:

{
  "status": 200,
  "data": {
    "id": 10432,
    "question": "Evaluate 2x + 3y if x = 2 and y = 4",
    "option": {
      "a": "16",
      "b": "14",
      "c": "12",
      "d": "10"
    },
    "answer": "a",
    "solution": "Substitute the values: 2(2) + 3(4) = 4 + 12 = 16.",
    "examtype": "JAMB",
    "examyear": "2022"
  }
}

That example comes from the current SdashAPI response documentation. SdashAPI

The important part isn't the exact question. It's the predictable structure.

Your application knows exactly where to find:

data.question
data.option
data.answer
data.solution
data.examyear

Fetch JAMB questions directly as JSON

The current V1 endpoint is:

GET https://sdashapi.com/api/v1/q

SdashAPI uses utme when filtering JAMB questions.

For example:

curl -X GET \
  "https://sdashapi.com/api/v1/q?type=utme&subject=mathematics" \
  -H "AccessToken: YOUR_API_KEY"

This is the request shown in the current developer documentation. SdashAPI

If you want Biology from 2022:

curl \
  "https://sdashapi.com/api/v1/q?subject=biology&type=utme&year=2022" \
  -H "AccessToken: YOUR_ACCESS_TOKEN"

SdashAPI recently published the same pattern specifically for developers looking for JAMB questions and answers in JSON format. SdashAPI

Fetch a complete practice session

One advantage of a JSON API is that you don't have to download questions one at a time.

Suppose a student selects:

UTME
Physics
2019
40 Questions

The documented request is:

GET https://sdashapi.com/api/v1/q?subject=physics&type=utme&year=2019&limit=40

SdashAPI currently allows up to 50 questions per request. SdashAPI

There's one implementation detail worth knowing.

When:

limit=1

data is an object.

When:

limit>1

data becomes an array of question objects. SdashAPI

So for multiple questions:

const response = await fetch(url, {
  headers: {
    AccessToken: process.env.SDASH_API_KEY
  }
});

const result = await response.json();

result.data.forEach(question => {
  console.log(question.question);
});

Your production API key should stay on your backend rather than being exposed in browser or mobile-app code. SdashAPI's authentication guide specifically warns against publishing API keys in frontend code or public repositories. SdashAPI

JSON makes automatic marking easy

Once the data is structured, marking becomes straightforward.

Suppose the API returns:

{
  "answer": "c"
}

and your student selects:

const selectedAnswer = "c";

You can compare them:

const correct = selectedAnswer === question.answer;

For a 40-question examination:

let score = 0;

questions.forEach((question) => {
  if (answers[question.id] === question.answer) {
    score++;
  }
});

This is one of the biggest differences between having JAMB questions in JSON and having them inside PDFs.

The application understands the data.

Don't use array position as your question ID

Suppose your JSON array contains:

Question 0
Question 1
Question 2
Question 3

It's tempting to store:

answers[2] = "b";

But array positions can change if questions are shuffled.

SdashAPI gives each question a unique integer id, and individual questions can also be fetched directly by that ID:

GET https://sdashapi.com/api/v1/q?id=8931
``` :chatgpt-content-reference{index="8"}


That lets you store:

```javascript
answers[8931] = "b";

The same ID can later support:

Bookmarks
Questions I Got Wrong
Attempt History
Share Question
Report Question

That's much safer than relying on the question's position on the screen.

A richer JAMB JSON database can include metadata

A basic CBT may only need:

question
options
answer
solution
year

But a more advanced revision app might want to know what the question is actually testing.

SdashAPI V2 currently adds a metadata object. Its API documentation lists fields including:

{
  "metadata": {
    "topic": "Organic Chemistry",
    "subtopic": "Alkanes",
    "difficulty": "medium",
    "type": "MCQ",
    "skill": "Recall",
    "tags": [
      "hydrocarbons",
      "covalent"
    ],
    "passage": null
  }
}
``` :chatgpt-content-reference{index="9"}


Now your JSON can support something more interesting than:

> Practice 50 random Chemistry questions.

You can build:

```text
Organic Chemistry
Mechanics
Genetics
Ecology
Algebra
Statistics

or analyse where students struggle.

One caution: metadata appearing in the returned JSON does not automatically mean every metadata field is available as a server-side query parameter. Use only filters documented by the API.

JSON explanations can go further too

For learning applications, the correct answer alone isn't always enough.

SdashAPI V3 currently adds an explanation block on top of the richer question structure:

{
  "explanation": {
    "summary": "Quick summary of the answer.",
    "detailed": "Detailed step-by-step reasoning...",
    "steps": [
      "Step 1...",
      "Step 2..."
    ],
    "why_correct": "Option B is correct because...",
    "why_others_wrong": {
      "a": "Incorrect because...",
      "c": "Incorrect because..."
    }
  }
}
``` :chatgpt-content-reference{index="10"}


That means the same JSON infrastructure can power:

```text
Practice Question
      ↓
Student Answers
      ↓
Wrong
      ↓
Why the Correct Answer Is Correct
      ↓
Why Their Option Was Wrong
      ↓
Try Again

instead of simply displaying a red X.

What about AI-powered JAMB apps?

This is where structured JSON becomes even more useful.

SdashAPI's current V4 documentation describes an intelligence layer that can return AI insights such as a hint and related concepts. SdashAPI

That can support an interface like:

Need help?

Hint:
Think about the organelle responsible
for producing ATP.

[ Show Answer ]

rather than revealing the correct answer immediately.

Structured JAMB data can therefore become grounding material for an AI tutor instead of asking an AI model to invent both the question and the answer.

JSON API or downloadable JSON file?

These are related, but they're not the same.

An API looks like:

Your App
   ↓
Your Backend
   ↓
SdashAPI
   ↓
JSON Response

This works well when you want current access without maintaining the entire question database yourself.

A downloadable dataset looks more like:

JAMB Dataset
     ↓
JSON Files
     ↓
Your PostgreSQL / MongoDB / SQLite
     ↓
Your App

That can be more appropriate when you're building a fully offline CBT product or need the complete dataset under your own infrastructure.

SdashAPI currently advertises bulk dataset licensing in formats including JSON, CSV and SQL for teams that require offline datasets. SdashAPI

So before asking for "JAMB JSON", decide which one you actually need:

JSON through an API for an online or hybrid application, or a bulk JSON dataset for storage in your own database.

Current UTME coverage

The current SdashAPI Coverage page reports:

UTME / JAMB

22 subjects
1988–2026 overall year range
82% explanations
Images available
V1–V4 supported
``` :chatgpt-content-reference{index="14"}


Those are overall UTME figures, not a guarantee that every subject has exactly the same coverage in every year.

Your application should handle unavailable combinations instead of assuming that every possible subject/year request will return questions.

## Why JSON is a better starting point for developers

The main benefit isn't that JSON looks neat.

It's that virtually every modern development stack understands it.

SdashAPI's current developer guide specifically documents JSON use across JavaScript, PHP and other languages, and its tutorial library includes integrations for JavaScript, Python, React, React Native, Flutter and Next.js. :chatgpt-content-reference{index="15"}

So the same JAMB question data can power:

```text
React website
React Native app
Flutter app
Node.js backend
PHP application
Python project
School CBT system
AI tutor

without rebuilding the question bank for every platform.

For an online application, developers can start with the SdashAPI documentation and fetch UTME questions directly as JSON. For projects that need the entire question database stored locally, the bulk dataset option is the more appropriate route.

A JAMB question database JSON is ultimately useful because it turns past questions from documents people can only read into structured data software can actually work with.