How Can I Get JAMB Past Questions Through an API?

If you are building a JAMB CBT app, UTME practice website, mobile learning app, mock exam platform or Nigerian education software, you can get JAMB past questions programmatically using the SdashAPI JAMB API.

SdashAPI provides a REST API that allows developers to retrieve structured JAMB/UTME past questions using simple HTTP requests.

Instead of manually typing and storing thousands of questions in your own database, your application can request the questions it needs and receive them as JSON.

SdashAPI can return information such as:

• Questions
• Answer options
• Correct answers
• Solutions and explanations
• Examination year
• Subject
• Question ID
• Section where applicable
• Images where available
• Additional metadata depending on the API version

SdashAPI is an independent educational API and is not an official API operated by JAMB.

Step 1: Create a SdashAPI Account

The first thing you need is a SdashAPI developer account.

After creating your account, you can access your developer dashboard and obtain your unique Access Token.

Your token is what authenticates requests made from your application.

Your request header will contain:

AccessToken: YOUR_ACCESS_TOKEN

SdashAPI requires the Access Token when accessing protected API resources.

Step 2: Make Your First JAMB API Request

The main V1 questions endpoint is:

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

For example, suppose you want a JAMB Chemistry question from 2022.

You can make this request:

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

Here:

subject=chemistry

specifies the subject.

type=utme

specifies that you want JAMB/UTME questions.

And:

year=2022

requests questions from that examination year.

What Does the JAMB API Return?

SdashAPI returns structured JSON that your application can read directly.

A response follows a structure similar to:

{
  "status": 200,
  "data": {
    "id": 4821,
    "question": "Which of the following is the chemical formula for table salt?",
    "section": null,
    "option": {
      "a": "NaCl",
      "b": "KCl",
      "c": "CaCO3",
      "d": "NaOH"
    },
    "answer": "a",
    "solution": "NaCl is sodium chloride.",
    "image": null,
    "examtype": "UTME",
    "examyear": "2022",
    "university": null
  }
}

This means your application does not need to parse HTML pages or manually convert questions into usable data.

You receive structured information that can be displayed directly inside your CBT interface.

Getting JAMB Questions With JavaScript

If you are using JavaScript, you can fetch JAMB questions like this:

fetch(
  "https://sdashapi.com/api/v1/q?subject=biology&type=utme&year=2023",
  {
    headers: {
      AccessToken: "YOUR_ACCESS_TOKEN"
    }
  }
)
  .then(response => response.json())
  .then(data => {
    console.log(data);
  })
  .catch(error => {
    console.error(error);
  });

Once the request succeeds, you can use the returned JSON to populate your CBT question screen.

Getting JAMB Questions With Python

Python developers can use the requests package:

import requests

url = "https://sdashapi.com/api/v1/q"

params = {
    "subject": "biology",
    "type": "utme",
    "year": "2023"
}

headers = {
    "AccessToken": "YOUR_ACCESS_TOKEN"
}

response = requests.get(
    url,
    params=params,
    headers=headers
)

data = response.json()

print(data)

SdashAPI also currently provides an official Python SDK for developers who prefer using a package instead of constructing HTTP requests manually.

Getting JAMB Questions With Node.js or TypeScript

SdashAPI also provides a JavaScript/TypeScript SDK.

You can install it with:

npm install @sdashapis/sdk

Then initialise SdashAPI:

import { SdashAPI } from "@sdashapis/sdk";

const api = new SdashAPI({
  apiKey: "YOUR_ACCESS_TOKEN"
});

async function getQuestion() {
  const question = await api.getQuestions({
    subject: "chemistry",
    type: "utme",
    year: 2022
  });

  console.log(question);
}

getQuestion();

The SDK currently supports operations such as fetching questions, retrieving subjects, retrieving supported examinations, getting available years and reporting question issues.

Can I Request Multiple JAMB Questions?

Yes.

SdashAPI supports a limit parameter.

For example:

https://sdashapi.com/api/v1/q?subject=biology&type=utme&limit=20

could be used to retrieve multiple Biology UTME questions.

The V1 API currently supports up to 50 questions in a request.

This is useful when creating a complete CBT session.

For example, your application could request:

subject=chemistry
type=utme
limit=40

and use the returned questions to build an examination session.

Can I Filter JAMB Questions by Year?

Yes.

One of the useful features of the SdashAPI JAMB API is examination-year filtering.

For example:

GET /api/v1/q?subject=physics&type=utme&year=2021

could be used to request Physics UTME questions for 2021.

You can simply change the year depending on what your application needs.

This makes it possible to create features such as:

• Practice JAMB 2021
• Practice JAMB 2022
• Practice JAMB 2023
• Practice JAMB 2024
• Practice JAMB 2025
• Practice JAMB 2026

without maintaining a separate question database for each year.

Can I Filter Questions by Subject?

Yes.

You can specify the subject inside the request.

For example:

?subject=mathematics&type=utme

or:

?subject=biology&type=utme

or:

?subject=chemistry&type=utme

or:

?subject=physics&type=utme

SdashAPI also provides endpoints that allow developers to retrieve supported subjects, examination types and years.

Can I Get Random JAMB Questions?

Yes.

The V1 questions endpoint can return random questions.

For example:

GET /api/v1/q?subject=biology

can return a random Biology question.

You can also combine parameters depending on what kind of random selection your application needs.

This can be useful for:

• Daily questions
• Practice mode
• Random CBT tests
• Quick quizzes
• Challenge modes
• Revision sessions

Build a Complete JAMB CBT App

Once you can retrieve the questions through the API, building a CBT interface becomes much easier.

Your application can:

1. Request questions from SdashAPI.
2. Display the question.
3. Display the available options.
4. Allow the student to select an answer.
5. Compare the selected option with the correct answer.
6. Calculate the student's score.
7. Display the solution after submission.
8. Move to the next question.

You can then add your own features such as timers, bookmarks, progress tracking, leaderboards and analytics.

The API handles the examination content while you concentrate on building your user experience.

SdashAPI V1, V2, V3 and V4

SdashAPI also provides different API versions depending on how much information your application needs.

V1

V1 provides the core information required for a CBT application, including:

• Question
• Options
• Answer
• Solution
• Exam type
• Exam year

V2

V2 provides richer classification and metadata.

Depending on the question, this may include information such as:

• Topic
• Subtopic
• Difficulty
• Skills
• Tags
• Passage information

This can be useful for creating topic-based JAMB practice.

V3

V3 focuses on richer explanations.

It can provide information useful for helping students understand not only the correct answer, but also the reasoning behind it.

V4

V4 introduces additional intelligent features including related-question functionality.

This can help developers build systems that recommend similar questions after a learner struggles with a particular concept.

Can I Get JAMB Novel Information Through the API?

SdashAPI also provides API functionality around educational novels.

This can be particularly useful for JAMB preparation applications that want to combine objective questions with novel-study features.

Your application can therefore build functionality around JAMB novel content alongside regular examination practice.

Use SdashAPI for React Native

If you're building a React Native CBT app, the API works the same way.

For example:

const loadQuestions = async () => {
  try {
    const response = await fetch(
      "https://sdashapi.com/api/v1/q?subject=english&type=utme&limit=20",
      {
        headers: {
          AccessToken: "YOUR_ACCESS_TOKEN"
        }
      }
    );

    const result = await response.json();

    console.log(result);
  } catch (error) {
    console.log(error);
  }
};

You can then save the returned questions into your application state and render them inside your CBT interface.

Can Flutter Developers Use SdashAPI?

Yes.

SdashAPI is a REST API, so Flutter applications can access it through normal HTTP requests.

The API is not restricted to a particular programming language or framework.

The SdashAPI documentation currently lists compatibility with technologies including JavaScript, React, React Native, Flutter, Node.js, PHP, Laravel, Python, Java, C# and Go.

Do I Need to Build My Own JAMB Questions Database?

Not necessarily.

That is one of the main reasons to use an API.

Without an API, you may have to manually:

• Collect questions
• Type questions
• Add answer options
• Verify answers
• Write explanations
• Categorise subjects
• Organise examination years
• Store images
• Create database tables
• Build question-selection logic
• Continuously maintain your dataset

Using SdashAPI allows your application to request this information through an API instead.

You can focus your development time on your actual product.

Keep Your SdashAPI Token Secure

You should treat your SdashAPI Access Token like a private credential.

Although SdashAPI supports providing a token as a query parameter for quick testing, the documentation recommends sending the token through the HTTP header for production use.

For production applications, it is also safer to avoid permanently exposing private API credentials inside publicly distributed frontend code where possible.

A backend or server-side proxy can provide additional protection for your API credentials.

What Can You Build With the JAMB API?

Once you have access to the questions, there are many possible products you can build.

Examples include:

• JAMB CBT mobile apps
• UTME preparation websites
• Mock JAMB examination platforms
• Tutorial-centre CBT systems
• AI tutors
• AI study assistants
• Student revision platforms
• School portals
• Educational games
• Question-of-the-day apps
• Topic-based practice tools
• Exam analytics platforms
• JAMB quiz bots

The same SdashAPI infrastructure also supports other Nigerian examination content including WASSCE, NECO and Post-UTME.

So, How Do I Get JAMB Past Questions Through an API?

The process is straightforward:

1. Create a SdashAPI account.
2. Get your Access Token from your dashboard.
3. Send a GET request to the SdashAPI questions endpoint.
4. Set type=utme.
5. Add the subject, year and limit you need.
6. Include your Access Token in the request header.
7. Receive the JAMB questions as structured JSON.
8. Use the response inside your website, mobile app or CBT platform.

For example:

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

That is all you need to begin retrieving JAMB questions programmatically.

You can read the full SdashAPI documentation for authentication, available endpoints, parameters, API versions and integration examples.