JAMB API with explanations

A JAMB API with explanations should do more than return a UTME question and tell your app which option is correct.

For a normal CBT simulator, this may be enough:

Question → Options → Correct Answer

For an actual learning app, a better flow is:

Question
   ↓
Student answers
   ↓
Correct / Incorrect
   ↓
Explanation
   ↓
Understand the concept
   ↓
Try another question

This is one of the areas where SdashAPI separates basic question retrieval from richer educational data. Its current UTME database covers 22 subjects across an overall 1988–2026 range, and the public coverage page reports explanations for about 82% of UTME questions. SdashAPI

First, JAMB questions are requested as UTME

Developers often search for "JAMB API", but SdashAPI uses utme as the exam filter.

A basic Mathematics request is:

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

That request format comes directly from the current documentation. SdashAPI

You can also combine subject and year:

GET https://sdashapi.com/api/v1/q?subject=chemistry&type=utme&year=2022
AccessToken: YOUR_ACCESS_TOKEN

The response includes structured fields such as the question, options, correct answer, solution, exam type and exam year. SdashAPI

V1 gives you the answer and solution

If you're building a lightweight JAMB CBT app, V1 may already contain everything you need.

Its documented structure includes:

{
  "question": "What is the unit of force?",
  "option": {
    "a": "Joule",
    "b": "Newton",
    "c": "Watt"
  },
  "answer": "b"
}

V1 is designed as the simpler, faster question endpoint and includes core question data, correct answers and static solutions where available. SdashAPI

This lets your app automatically mark an attempt:

const isCorrect = selectedOption === question.answer;

Then, after the student answers, you can display solution if one is available.

But a solution and a detailed explanation are different

Suppose a student gets a Physics calculation wrong.

A short solution might say:

Using F = ma, F = 5 × 4 = 20 N.

That's useful.

But a proper revision application may want more structure:

Quick explanation

Detailed reasoning

Step-by-step solution

Why the correct option is correct

Why the other options are wrong

For this, SdashAPI's current API reference documents V3 as the explanations layer. SdashAPI

The endpoint is:

GET https://sdashapi.com/api/v3/q?type=utme&subject=physics
AccessToken: YOUR_ACCESS_TOKEN

The documented explanation structure can include:

{
  "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="5"}


This is much easier to turn into a useful revision interface than one giant block of text.

## A better JAMB review screen

Instead of:

```text
You selected: C

Correct answer: B

you could build:

QUESTION 14

Your answer: C
Correct answer: B

WHY B IS CORRECT
The explanation appears here...

STEP-BY-STEP
1. ...
2. ...
3. ...

WHY C IS WRONG
...

[ Next Question ]

That changes the purpose of the application.

The student isn't only finding out that they failed Question 14. They're being shown what they misunderstood.

Don't show explanations during a real mock

There should also be a difference between Practice Mode and Mock Mode.

Practice Mode

You can show:

Question
   ↓
Answer
   ↓
Check
   ↓
Explanation
   ↓
Next

Mock Mode

Use:

40 Questions
     ↓
Timer Starts
     ↓
Student Answers
     ↓
Submit
     ↓
Calculate Score
     ↓
Review Questions
     ↓
Show Explanations

SdashAPI's own answer guide warns that the correct answer is present in the API response. For stricter testing environments, it recommends proxying requests through your backend, removing the answer before sending questions to the student, and performing grading server-side. SdashAPI

That's a much better architecture for a serious CBT product.

Explanations are especially useful for "Questions I Got Wrong"

One of the simplest features you can build is also one of the most useful.

Store the IDs of incorrectly answered questions:

if (selectedAnswer !== question.answer) {
  wrongQuestions.push(question.id);
}

Then create:

QUESTIONS YOU GOT WRONG

Mathematics       12
Physics            8
Chemistry          5
English            9

The student can return later and review:

Original question
      ↓
Their answer
      ↓
Correct answer
      ↓
Explanation
      ↓
Try again

Now past questions become a personalised revision system.

Combine explanations with topic information

SdashAPI V2 adds metadata such as topic and subtopic information, while higher versions build on the lower layers. The current documentation describes V2 as the metadata/taxonomy layer and V3 as the explanation layer. SdashAPI

That can lead to something much more interesting than a normal CBT result:

YOUR PHYSICS PERFORMANCE

Mechanics              78%
Waves                  69%
Electricity            41%
Optics                  73%

Focus Area:
Electricity

The student can then open the questions they missed under Electricity and read the corresponding explanations.

The result page stops being the end of the session. It becomes the beginning of the next revision session.

Explanations also make an AI tutor more grounded

There's another useful architecture for developers building AI features.

Instead of asking an AI model to invent everything:

AI
 ↓
Generate JAMB question
 ↓
Guess answer
 ↓
Generate explanation

you can use existing exam data as the foundation:

UTME Question
      ↓
Correct Answer
      ↓
Existing Explanation
      ↓
AI Tutor
      ↓
Student asks follow-up questions

For example:

Why isn't option C correct?

or:

Explain this like I'm a beginner.

or:

Give me another example using the same formula.

The original question and explanation give your tutoring layer useful context.

SdashAPI's current API architecture goes further with metadata and intelligence features for applications building adaptive or AI-assisted learning experiences. SdashAPI

Not every question will have an explanation

This is important when designing your UI.

The current coverage page reports explanations for approximately 82% of UTME questions, not 100%. SdashAPI

So your frontend shouldn't assume:

question.explanation.detailed

always exists.

A safer approach is:

if (question.explanation?.detailed) {
  // Show detailed explanation
} else if (question.solution) {
  // Show standard solution
} else {
  // Show the correct answer only
}

Your app remains usable even when a particular historical question doesn't have a detailed explanation.

Which SdashAPI version should you use?

Don't automatically choose the largest response.

For a simple timed JAMB simulator, V1 may be enough because you mainly need questions, options, answers and solutions. SdashAPI

If you're building a categorized study experience, look at the metadata available beyond V1. SdashAPI

If detailed explanations are central to your product, the current API reference identifies V3 as the explanation-focused endpoint. SdashAPI

And if you're building more advanced intelligent learning features, inspect the current V4 documentation before deciding whether those capabilities are necessary. SdashAPI

This matters for performance and usage too. SdashAPI's current credit guide says V1 is the baseline request, while richer endpoints can carry higher credit costs because they require additional processing. SdashAPI

How much JAMB data is currently available?

The current SdashAPI Coverage page reports:

UTME / JAMB

22 subjects
1988–2026 overall year range
82% explanations
Images available
V1, V2, V3 and V4
``` :chatgpt-content-reference{index="15"}


That doesn't mean every subject necessarily contains the same number of questions for every year, so applications should still handle unavailable combinations properly.

## Build for learning, not just marking

A JAMB app that says:

> You scored 47%.

has completed the marking process.

A better application asks:

> Why did you score 47%, and what should you study next?

That's where explanations become useful.

The combination of past questions, correct answers, solutions, structured explanations and metadata can produce a learning loop like:

```text
Practice
   ↓
Make Mistakes
   ↓
Read Explanations
   ↓
Identify Weak Areas
   ↓
Practice Again
   ↓
Improve

For developers building that kind of product, SdashAPI provides UTME questions through its REST API, while the SdashAPI documentation explains the different data available across its API versions. SdashAPI