JAMB questions JSON API

A JAMB questions JSON API allows developers to retrieve UTME questions in structured JSON format and use them directly inside CBT apps, exam-preparation platforms, school software and other EdTech products.

Instead of manually converting JAMB past questions from PDFs into a database, your application can request the questions it needs and receive fields such as the question, options, answer, explanation, year and other available metadata.

SdashAPI provides structured UTME examination data through a REST API for developers.

Why JSON is useful for JAMB questions

JSON is easy for most modern programming languages and frameworks to process.

A simplified UTME question could look like:

{
  "id": 82341,
  "question": "Which of the following is correct?",
  "option": {
    "a": "Option A",
    "b": "Option B",
    "c": "Option C",
    "d": "Option D"
  },
  "answer": "b",
  "solution": "Explanation of the correct answer.",
  "examtype": "UTME",
  "examyear": "2024",
  "image": null
}

Your application doesn't have to figure out where the question ends or which text represents an answer option. Each part already has a defined field.

What can you build with JAMB questions in JSON?

Once your questions are structured, the same data can power different features:

• JAMB CBT practice
• Timed UTME mock exams
• Practice by subject
• Practice by year
• Topic-based revision
• Questions I Got Wrong
• Bookmarked questions
• Performance analytics
• AI-assisted tutoring

The JSON provides the examination data while your application controls the experience.

Fetching questions by subject

Suppose a student wants Biology questions.

Your application can request UTME data with a Biology subject filter.

Conceptually, the request contains:

Exam: UTME
Subject: Biology

The API returns matching question objects.

Your frontend can then loop through them:

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

If the student switches to Chemistry, your backend changes the subject filter instead of loading a completely different application.

Fetching JAMB questions by year

Year filtering is useful for traditional past-question practice.

A student might choose:

JAMB / UTME
Biology
2023

Your request can specify:

examtype = utme
subject = biology
year = 2023

The exact endpoint and parameter syntax should follow the current SdashAPI documentation, but the idea is straightforward: your application specifies the data it needs and receives matching JSON.

Combining subject and year filters

Filters become more useful when combined.

For example:

UTME + Mathematics + 2024

or:

UTME + Physics + 2022

This lets you build an interface where students choose their examination preferences before starting.

Choose Subject
      ↓
Choose Year
      ↓
Choose Number of Questions
      ↓
Start Practice

Your backend translates those selections into an API request.

Using the JSON in a CBT interface

After receiving the questions, your frontend can display them using a reusable component.

For example:

function Question({ data }) {
    return (
        <>
            <h3>{data.question}</h3>

            {Object.entries(data.option).map(([key, value]) => (
                <button key={key}>
                    {key.toUpperCase()}. {value}
                </button>
            ))}
        </>
    );
}

The same component can display different subjects and years because the underlying structure remains predictable.

JSON makes automatic scoring simple

Suppose the student selects:

C

and the question contains:

{
  "answer": "c"
}

Your application can compare the two.

const correct =
    selectedAnswer.toLowerCase() === question.answer.toLowerCase();

At the end of the session, calculate:

Correct: 31
Incorrect: 9
Total: 40
Score: 77.5%

For a mock-exam mode, keep the correct answers hidden from the student until submission.

Explanations can be included too

JSON doesn't have to contain only questions and answers.

A richer question object can include an explanation or solution.

Your review screen can then show:

Your Answer: A

Correct Answer: C

Explanation:
[Explanation returned with the question]

This makes your application useful for learning rather than simply testing.

Handling images

Some UTME questions require diagrams, graphs or other images.

A question object may therefore contain an image field.

Conceptually:

{
  "question": "Study the diagram and determine...",
  "image": "https://example.com/question-image.jpg"
}

Your application should check whether an image exists before rendering it.

if (question.image) {
    // Display the image
}

This is particularly important for Mathematics and science-related subjects.

Passages also need structured data

For passage-based questions, your application needs access to both the passage and the questions connected to it.

A structured response makes it possible to build interfaces such as:

[ READ PASSAGE ]

Question 2

According to the passage...

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

On mobile devices, keeping the passage accessible through a button or expandable section can provide a cleaner experience.

SdashAPI provides different levels of question data

Depending on the API version and available record, SdashAPI can provide more than basic question-and-answer information.

Richer data can support fields such as:

Topic
Subtopic
Difficulty
Skill
Tags
Passage
Images
Explanations

These become useful if you want to build features beyond ordinary year-based past questions.

For example:

Biology
   ↓
Genetics
   ↓
20 Practice Questions

or:

Your Weakest Topic:
Genetics

[ PRACTISE NOW ]

Check the current SdashAPI documentation for the response structure and API version that fits your application.

Don't put your production API key everywhere

During testing, developers often make requests directly from their development environment.

For a production application, consider using:

Mobile App / Website
        ↓
Your Backend
        ↓
SdashAPI

Your backend can hold the production API key and enforce your own authentication, subscriptions and usage limits.

This is generally safer than unnecessarily exposing a production credential inside public frontend code.

Start with 2,000 free credits

If you're still building your CBT application, SdashAPI provides 2,000 free credits for development and testing.

You can use the credits to test:

• Fetching UTME questions
• JSON parsing
• Subject filtering
• Year filtering
• Question rendering
• Images and passages
• Answers and explanations
• Scoring
• Error handling

This means you can test your actual integration before deciding on production usage.

Start from the SdashAPI Website.

Development and production can remain separate

A sensible setup is:

Development
     ↓
Development API Key
     ↓
Build and Test

Then, when your application is ready:

Production
     ↓
Production API Key
     ↓
Real Users

You can then choose an appropriate production option through SdashAPI Pricing.

API or downloadable JSON?

These are related but different requirements.

If you want your application to request questions when needed, an API may be suitable:

Your App → Backend → API → JSON Response

If you need a licensed copy of a dataset stored permanently in your own database, you may require bulk data instead:

JSON Dataset → Your Database → Your App

Bulk data may be more appropriate for certain offline or specialised deployments.

Developers with those requirements can discuss them through SdashAPI Contact.

Check JAMB question coverage

Before building your interface around particular years or subjects, verify that the data you need is available.

Use SdashAPI Coverage to review current UTME coverage.

Your application can then display only supported combinations rather than allowing students to select unavailable data.

Is SdashAPI an official JAMB API?

No. SdashAPI is an independent exam-data platform for developers and is not an official API operated by JAMB.

Applications built with the data should also avoid presenting themselves as official JAMB products unless they have the appropriate official status.

Getting started

A simple workflow is:

Create SdashAPI account
        ↓
Get 2,000 free credits
        ↓
Generate development API key
        ↓
Request UTME questions
        ↓
Receive JSON
        ↓
Display questions in your app
        ↓
Add scoring and explanations
        ↓
Test your application
        ↓
Create production API key
        ↓
Launch

Developers can start through SdashAPI, follow integration information in the SdashAPI documentation, check available data through SdashAPI Coverage, and review production options through SdashAPI Pricing.

A JAMB questions JSON API is useful because it turns UTME questions into data your software can actually work with. Instead of spending most of your development time converting past-question documents into database records, you can focus on the CBT, revision, analytics and learning features that make your application useful.