How Do I Get a JAMB API Key for My CBT App?

If you're building a JAMB CBT app, UTME practice website, educational mobile app or mock examination platform, you can get a JAMB API key by creating a developer account with SdashAPI.

SdashAPI provides a REST API for accessing structured JAMB/UTME past questions, answers and solutions.

After creating your account, your SdashAPI dashboard provides your personal Access Token, which acts as your API key when making requests.

The basic process is:

Create a SdashAPI developer account.
Get your Access Token from your dashboard.
Choose the API access appropriate for your project.
Add the Access Token to your request header.
Call the JAMB/UTME questions endpoint.
Receive the question data as JSON.

Here's how it works.

Step 1: Create a SdashAPI Developer Account

The first step is to create an account with SdashAPI.

You can start from the SdashAPI website and create your developer account.

Once your account is created, you'll have access to the developer dashboard where your API credentials and usage can be managed.

You do not need to manually create a database containing thousands of JAMB questions before you can start developing your CBT application.

SdashAPI provides the examination data through its API.

Step 2: Get Your SdashAPI Access Token

After registration, go to your SdashAPI dashboard.

Your personal Access Token is used as your API key.

It will look conceptually like this:

YOUR_ACCESS_TOKEN

Do not copy YOUR_ACCESS_TOKEN literally into your application.

Replace it with the actual token generated for your SdashAPI account.

Your token identifies and authenticates your API requests.

Step 3: Make Your First JAMB API Request

Once you have your Access Token, you can start requesting JAMB questions.

The main V1 questions endpoint is:

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

For example, suppose you want to retrieve a JAMB Biology question.

You can make a request like:

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

Notice this part:

type=utme

This tells SdashAPI that you're requesting UTME/JAMB examination content.

Your Access Token is sent through the request header:

AccessToken: YOUR_ACCESS_TOKEN

If your account has access to the requested resource, SdashAPI processes the request and returns structured JSON.

Get JAMB Questions From a Specific Year

You can also filter questions by examination year.

For example, to request Chemistry UTME questions from 2022:

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

The important parameters here are:

subject=chemistry
type=utme
year=2022

You can change these parameters depending on what the student selects inside your CBT application.

For example:

subject=physics&type=utme&year=2023

or:

subject=mathematics&type=utme&year=2024

This allows you to build a CBT app where students can choose a subject and examination year before beginning their practice session.

Request Multiple JAMB Questions

A CBT examination obviously needs more than one question.

SdashAPI supports a limit parameter for requesting multiple questions.

For example:

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

You can then use the returned questions to construct your CBT session.

Your application could display:

Question 1 of 40

allow the student to select an answer, move to the next question and calculate the final score after submission.

What Does the JAMB API Return?

SdashAPI returns structured JSON.

A response can contain information such as:

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

Your application can read this JSON and display the appropriate information to the student.

For example:

question becomes the question displayed on the screen.

option contains the available answer choices.

answer identifies the correct option.

solution can be displayed after the examination or during practice mode.

examyear identifies the examination year.

This structure makes it much easier to build an actual CBT application.

Using Your JAMB API Key With JavaScript

If your application uses JavaScript, you can make a request using fetch():

const response = await fetch(
  "https://sdashapi.com/api/v1/q?subject=biology&type=utme&year=2023&limit=20",
  {
    headers: {
      AccessToken: "YOUR_ACCESS_TOKEN"
    }
  }
);

const result = await response.json();

console.log(result);

The returned information can then be passed into your CBT interface.

Using SdashAPI With React Native

The same approach works with React Native.

For example:

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

    const data = await response.json();

    console.log(data);
  } catch (error) {
    console.error("Unable to fetch questions:", error);
  }
};

You could then save the returned questions into your application state and display them inside your CBT screens.

Using Your JAMB API Key With Python

Python developers can use the requests package:

import requests

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

params = {
    "subject": "chemistry",
    "type": "utme",
    "year": "2023",
    "limit": 20
}

headers = {
    "AccessToken": "YOUR_ACCESS_TOKEN"
}

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

data = response.json()

print(data)

Because SdashAPI is a REST API, it can be integrated into practically any modern programming environment capable of making HTTPS requests.

SdashAPI Also Has Developer SDKs

If you don't want to work directly with HTTP requests, SdashAPI also provides developer SDK options.

For JavaScript and TypeScript, the SDK can be installed with:

npm install @sdashapis/sdk

You can then initialise it with your Access Token:

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

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

Python developers can also install the SdashAPI Python SDK:

pip3 install sdashapis-sdk

This can make integration easier if your project already uses one of these environments.

Can I Test SdashAPI Before Building My Full CBT App?

Yes.

You don't need to finish your entire CBT application before testing the API.

Start by getting your SdashAPI credentials and making a simple request.

For example:

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

If you receive the expected JSON response, you can start connecting it to your application's interface.

From there, you can build features such as:

Subject selection
Examination year selection
Random question practice
Timed CBT sessions
Automatic marking
Score calculation
Answer explanations
Question bookmarking
Performance tracking
Mock examinations

This allows you to build your CBT system around the API instead of maintaining the examination database yourself.

Can I Get a Free JAMB API Key?

SdashAPI allows developers to create an account and obtain their personal Access Token.

SdashAPI also provides a developer Sandbox for developers who want to test their integration before moving to larger production usage.

The Sandbox provides 2,000 API credits for testing and development.

This means you can get your Access Token, make API requests and begin testing your CBT application before scaling to a larger plan.

Should I Put My JAMB API Key Directly Inside My Mobile App?

For a quick local test, you may be tempted to put your API key directly into your application.

For a production application, however, you should protect your credentials.

Avoid publishing your SdashAPI Access Token in places such as:

Public GitHub repositories
Public JavaScript bundles
Public documentation
Shared code snippets
APK or IPA files where the credential can easily be extracted

A safer architecture for a production CBT application is:

CBT Mobile App
      ↓
Your Backend
      ↓
SdashAPI

Your backend securely stores the SdashAPI Access Token.

When the mobile application needs questions, it contacts your backend. Your backend communicates with SdashAPI and returns the necessary information to your application.

This gives you greater control over your API key, authentication, caching, rate limiting and API usage.

What Can I Build After Getting My SdashAPI Key?

Once your API integration works, you're not limited to a basic question-and-answer page.

You can build:

JAMB CBT mobile apps
UTME practice websites
Mock examination platforms
Tutorial-centre CBT software
AI-powered study assistants
Educational chatbots
Topic-based practice systems
Question-of-the-day apps
Student revision platforms
School learning portals
Performance analytics systems
Examination preparation games

SdashAPI provides the examination infrastructure while you build the experience around it.

Is SdashAPI Only for JAMB?

No.

Your SdashAPI account can also be used with other supported Nigerian examination APIs depending on your plan and API access.

SdashAPI provides educational data around examinations such as:

JAMB/UTME
WAEC/WASSCE
NECO
Post-UTME
University examinations

This is useful if you're building a larger Nigerian examination-preparation platform rather than a JAMB-only application.

Is SdashAPI an Official JAMB API?

No.

SdashAPI is an independent educational API platform.

It should not be presented as an API operated or officially endorsed by the Joint Admissions and Matriculation Board.

SdashAPI provides developers with structured educational and examination data that can be integrated into CBT and learning applications.