JAMB mock exam API

A JAMB mock exam API provides the UTME question data developers need to build timed JAMB mock examinations inside CBT apps, websites and exam-preparation platforms.

The API does not need to control your entire mock examination. Your application handles the timer, navigation, submission and results, while the API supplies structured UTME questions.

With SdashAPI, the basic architecture can be:

Student
   ↓
Your JAMB CBT App
   ↓
Your Backend
   ↓
SdashAPI
   ↓
UTME Questions

Using the real SdashAPI question endpoint

According to the current SdashAPI documentation, questions can be requested from:

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

Your access token is supplied using the AccessToken header.

For example, to request UTME Physics questions from 2019:

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

This combines four useful parameters:

subject = physics
type    = utme
year    = 2019
limit   = 40

The current API documentation allows up to 50 questions in a request, making it possible to prepare a complete practice session without requesting a new question every time the student presses Next.

You can confirm current parameters and examples in the SdashAPI Documentation.

Creating a mock examination

Suppose a student chooses:

JAMB Mock Exam

Subject: Biology
Questions: 40
Duration: 30 minutes

Your application can request the questions first:

GET https://sdashapi.com/api/v1/q?subject=biology&type=utme&limit=40
AccessToken: YOUR_ACCESS_TOKEN

Then create the examination session:

Fetch 40 questions
        ↓
Questions successfully loaded
        ↓
Create mock session
        ↓
Start 30-minute timer
        ↓
Student answers questions
        ↓
Submit
        ↓
Calculate result

The important detail is that the timer should start after the questions are ready.

Students shouldn't lose examination time because the network is still loading the question bank.

Example with JavaScript

A backend request could look like:

const response = await fetch(
  "https://sdashapi.com/api/v1/q?subject=biology&type=utme&limit=40",
  {
    headers: {
      AccessToken: process.env.SDASH_API_KEY
    }
  }
);

const result = await response.json();

const questions = result.data;

When multiple questions are requested, your application should handle data as the returned collection according to the documented response structure.

From there, you can create your own examination session.

Don't expose answers during the mock

A practice mode and a mock examination should behave differently.

In normal practice, you might show:

You selected: C
Correct answer: B

Explanation:
...

immediately after a question.

For mock mode, don't reveal that information until the examination has ended.

A better flow is:

Question
   ↓
Student selects B
   ↓
Save B
   ↓
Next Question

After submission:

Score: 32/40

[ Review Answers ]

The review screen can then display correct answers and explanations.

For stronger exam-mode control, your backend can prepare a sanitised question payload for the frontend and handle grading server-side.

Store answers using question IDs

As students move through the mock examination, save their responses against each question ID.

For example:

{
  "question_id": 82341,
  "selected_answer": "c"
}

Your session might eventually contain:

{
  "answers": [
    {
      "question_id": 82341,
      "selected_answer": "c"
    },
    {
      "question_id": 82342,
      "selected_answer": "a"
    }
  ]
}

This makes navigation, grading and later review much easier.

Add a proper question navigator

A JAMB-style CBT interface should allow students to move between questions.

For example:

Time Remaining: 24:16

Question 7 of 40

[Question]

A. ...
B. ...
C. ...
D. ...

[ Previous ]       [ Next ]

1  2  3  4  5
6  7  8  9  10
...

You can visually distinguish:

Current question
Answered questions
Unanswered questions
Questions marked for review

This part is controlled by your application, not the API.

Generate different mock sessions

You don't have to give every student exactly the same 40-question session.

Your backend can create different sessions from the available question pool.

You can also build modes such as:

Random UTME Mock

2024 UTME Practice

Biology Mock

Physics Mock

Mixed-Year Practice

Where the API supports the required filters, your backend changes the request according to what the student selects.

Use explanations after submission

A mock examination becomes more useful when students can learn from their mistakes.

After submission:

Question 18

Your Answer: D
Correct Answer: B

Explanation:
[Explanation returned with the question]

You can also save incorrectly answered question IDs and create:

Questions I Got Wrong

That gives students a personalised revision list after several mock examinations.

Track mock performance

Your own database can store:

user_id
mock_id
subject
questions_attempted
correct_answers
incorrect_answers
score
time_used
date

This lets you build a dashboard such as:

Your Recent Mocks

Biology       72%
Chemistry     64%
Physics       81%
Mathematics   58%

The API supplies question data. Your application owns the student analytics and experience.

Start with 2,000 free credits

Developers can use 2,000 free SdashAPI credits during development and testing.

You can use these credits to test your mock-exam flow with actual API responses:

Create account
      ↓
Get 2,000 free credits
      ↓
Generate development API key
      ↓
Call /api/v1/q
      ↓
Build mock session
      ↓
Test timer + navigation
      ↓
Test scoring

Start through SdashAPI and use the SdashAPI Documentation for the current endpoint details.

Moving your mock app to production

Once your application works correctly, create a separate production API key rather than continuing to use your development setup.

A good production structure is:

React Native / Flutter / Web
             ↓
        Your Backend
             ↓
     Production API Key
             ↓
          SdashAPI

Your backend can manage subscriptions, authentication, usage controls and mock sessions while keeping the production API credential private.

Current production options are available through SdashAPI Pricing.

You should also check SdashAPI Coverage before promising particular UTME subjects or years in your application.

SdashAPI is an independent examination-data platform and is not an official JAMB service.

A JAMB mock exam API is most useful when you treat it as the question-data layer rather than the entire CBT product. Fetch the UTME questions you need, then build your own timer, navigation, scoring, results, revision and student analytics around that data.