How to Add JAMB Past Questions to Your App Using an API

Building a JAMB practice app doesn’t mean you have to manually create and maintain thousands of question records yourself.

With an API, developers can connect their application to an examination-content service and retrieve structured JAMB questions whenever their application needs them.

SdashAPI provides developers with an API for integrating Nigerian examination content into mobile applications, websites, CBT platforms, and other educational products.

In this guide, we’ll explain how you can use SdashAPI to add JAMB questions to your own application.

Why Add JAMB Questions Through an API?

Suppose you’re building a JAMB CBT application.

Without an API, you may need to manually create database records containing:

• Questions
• Options
• Correct answers
• Subjects
• Examination years
• Solutions
• Topics
• Subtopics
• Other question metadata

As your database grows, maintaining everything becomes increasingly difficult.

An API provides another approach.

Your application requests the content it needs, receives structured data, and displays it to the user.

The basic architecture looks like this:

Your App ↓ Your Backend ↓ SdashAPI ↓ JAMB Question Data ↓ JSON Response ↓ Your Application ↓ Student

⸻

What Can You Build With SdashAPI?

Once JAMB question data is available inside your application, you can build many different features.

For example:

• JAMB CBT practice
• Mock examinations
• Subject-based practice
• Year-based practice
• Random quizzes
• Revision mode
• Answer review
• Detailed solutions
• Topic practice
• Performance tracking
• Question bookmarking
• Personalised practice

The API supplies the examination data while your application controls the user experience.

⸻

Step 1: Create Your Application

You can build your application using your preferred technology.

For example, you could use:

Mobile

• React Native
• Flutter
• Android
• iOS

Web

• React
• Next.js
• Vue
• JavaScript
• HTML/CSS/JavaScript

Backend

• Node.js
• Python
• PHP
• Laravel
• Java

The important requirement is that your application can make HTTP requests and process JSON responses.

⸻

Step 2: Get SdashAPI Access

Before your application can retrieve protected API resources, you’ll need your SdashAPI API access credentials.

Your access token is used when making authenticated requests.

For example:

AccessToken: YOUR_ACCESS_TOKEN

Keep private credentials on your backend where possible rather than exposing sensitive API credentials directly inside a publicly distributed application.

⸻

Step 3: Request JAMB Questions

Once your application has API access, you can make a request to the appropriate SdashAPI endpoint.

For example:

https://sdashapi.com/api/v1/q?subject=physics&type=utme&year=2022

You can modify the parameters based on what your application needs.

For example:

subject=physics

requests Physics content.

You could change it to:

subject=chemistry

for Chemistry.

You can also specify an examination year where supported:

year=2022

⸻

Step 4: Authenticate the Request

A request can include your SdashAPI access token.

For example:

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

SdashAPI then processes the request and returns the available data.

Always check the current SdashAPI documentation for the latest endpoint names, parameters and authentication requirements.

⸻

Step 5: Receive the JSON Response

Your application can receive structured JSON.

For example:

{ "status": 200, "data": [ { "id": 4821, "question": "Sample JAMB Physics question...", "option": { "a": "Option A", "b": "Option B", "c": "Option C", "d": "Option D" }, "answer": "c", "solution": "Explanation of the correct answer...", "examtype": "JAMB", "examyear": "2022" } ] }

Your application can then read the returned fields and display them.

For example:

const questions = result.data;

You can then loop through the questions and render them in your CBT interface.

⸻

Step 6: Display the Question

Once the JSON has been received, your application can display the question.

For example:

JAMB Physics Question 1 Sample examination question... A. Option A B. Option B C. Option C D. Option D

The student interacts with your application—not directly with the API.

That means you have complete control over the design.

You can use your own:

• Fonts
• Colours
• Buttons
• Animations
• Navigation
• Branding
• Layout
• CBT interface

⸻

Step 7: Let the Student Select an Answer

Your application can save the student’s selection.

For example:

const selectedAnswer = "c";

The application can store the answer alongside the question ID.

For a full examination, you could maintain an answer object:

const answers = { 1: "c", 2: "a", 3: "d", 4: "b" };

Your backend or frontend can then use the answer data to calculate the student’s result according to your application design.

⸻

Step 8: Calculate the Score

After the student submits the examination, compare the student’s answers against the correct answers supplied by the question data.

For example:

Questions: 40 Correct: 32 Incorrect: 8 Score: 80%

You can then save the result to your own database.

This allows you to build student-performance features independently of SdashAPI.

⸻

Step 9: Add a Timer

For a CBT application, you can create a timer around the questions.

For example:

TIME REMAINING 01:34:25

Your application can determine what happens when the timer reaches zero.

For example:

Timer expires ↓ Automatically submit ↓ Calculate score ↓ Display result

The timer and submission system are part of your application logic.

⸻

Step 10: Add Question Navigation

A professional CBT interface should allow students to move between questions.

For example:

[1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [Previous] [Next]

You can also indicate which questions have been answered.

For example:

✓ Answered ○ Unanswered

This creates a more familiar examination experience.

⸻

Step 11: Add Answer Review

After submitting a test, your application can show students what they got right and wrong.

For example:

Question 7 Your answer: B Correct answer: D ❌ Incorrect

You can then provide the explanation when available.

This is where structured answer and solution data becomes particularly useful.

⸻

Step 12: Add Explanations

Students often learn more from understanding their mistakes than simply seeing a score.

SdashAPI’s API architecture includes detailed explanation functionality for supported content.

Your application can therefore create a review screen such as:

Question 7 Correct Answer: D Explanation: The correct answer is D because...

This can turn your application into a learning platform rather than just a test-taking application.

⸻

Step 13: Add Subject Practice

You can create a subject-selection screen:

JAMB Practice English Mathematics Physics Chemistry Biology Economics Government Literature

When the student chooses a subject, your application sends the corresponding request to SdashAPI.

For example:

subject=mathematics

The returned content can then be displayed inside your Mathematics practice interface.

⸻

Step 14: Add Year-Based Practice

You can also let students choose an examination year.

For example:

Select Year 2024 2023 2022 2021 2020

Your application can pass the selected year to the API.

For example:

year=2023

This makes it possible to create dedicated experiences such as:

JAMB 2023 Mathematics Practice

or:

JAMB 2022 Physics Practice.

⸻

Step 15: Add Topic-Based Practice

A more advanced application can allow students to select specific topics.

For example:

Mathematics Algebra Geometry Statistics Probability Trigonometry

SdashAPI’s metadata and taxonomy capabilities can help developers build more detailed question organisation where the relevant metadata is available.

This can allow you to create targeted practice rather than forcing students to practise an entire subject at once.

⸻

Step 16: Build a Random Practice Mode

Not every student wants to practise questions in examination-year order.

You can build a random practice feature.

For example:

Random JAMB Practice Subject: Chemistry Questions: 30 [START]

Your application can retrieve suitable questions and select the questions to include in the session according to your own logic.

You can also create different difficulty levels where the available metadata supports it.

⸻

Step 17: Build a Mock Examination

Once the basic integration works, you can build a complete mock examination system.

For example:

JAMB MOCK EXAM English Mathematics Physics Chemistry 180 Questions Time: 2 Hours

The student begins the examination.

Your application manages:

• Timer
• Question navigation
• Answer selection
• Submission
• Scoring
• Results

SdashAPI provides the underlying question content.

⸻

Step 18: Save Student Progress

You can connect your application to your own database.

For example:

Student ↓ Test History ↓ Scores ↓ Subjects ↓ Topics ↓ Performance

You could store:

• Questions attempted
• Questions answered correctly
• Questions answered incorrectly
• Test scores
• Practice history
• Favourite questions
• Weak subjects
• Completed examinations

This gives you the foundation for personalised learning.

⸻

Step 19: Build a Weakness Detection System

Once you have saved student results, you can analyse their performance.

For example:

Student Performance Mathematics 82% English 88% Chemistry 76% Physics 61%

Your application can identify Physics as an area requiring additional practice.

You can then recommend more Physics questions.

This is application-level intelligence built around the examination content supplied through SdashAPI.

⸻

Step 20: Use Related Questions

Advanced learning applications can go even further.

SdashAPI V4 introduces related-question functionality, which can help applications discover questions connected to another question where supported.

You could create a flow such as:

Student answers incorrectly ↓ Show explanation ↓ Find related question ↓ Practice again

This can make the application more useful for students who want to understand concepts rather than simply memorise answers.

⸻

Keep Your API Credentials Secure

One important consideration when integrating any API is credential security.

Avoid exposing sensitive API credentials unnecessarily.

For applications where the API credential should remain private, a common architecture is:

Mobile App ↓ Your Backend ↓ SdashAPI

Your backend makes the authenticated request and sends the appropriate data to your application.

This gives you more control over:

• Authentication
• Rate limiting
• Caching
• Access control
• Logging
• API usage

⸻

Can You Use SdashAPI With React Native?

Yes.

A React Native application can make HTTP requests and process JSON responses.

A simplified example:

const response = await fetch( "https://sdashapi.com/api/v1/q?subject=physics&type=utme&year=2022", { headers: { AccessToken: "YOUR_ACCESS_TOKEN" } } ); const result = await response.json(); console.log(result.data);

Your application can then render the returned questions.

⸻

Can You Use SdashAPI With Flutter?

Yes.

Flutter applications can communicate with REST APIs and decode JSON responses.

The returned question data can then be converted into Dart models and displayed inside your CBT interface.

This means you can use SdashAPI regardless of whether you’re building your product with React Native, Flutter or another suitable technology.

⸻

Can You Use SdashAPI With a Website?

Yes.

Web applications can make requests to APIs and process JSON responses.

You can therefore build:

• JAMB practice websites
• CBT websites
• Online quiz platforms
• Educational portals
• Revision websites

and use SdashAPI as the examination-content layer.

⸻

What Makes SdashAPI Useful for Developers?

The biggest advantage is separation.

You don’t have to build your entire educational product around someone else’s interface.

You can create your own product.

Your application can handle:

• Branding
• User accounts
• Payments
• Subscriptions
• CBT interface
• Timer
• Scoring
• Analytics
• Notifications
• Gamification

SdashAPI handles the examination-content side.

⸻

Build Your Own Educational Product

An API should not limit what you can build.

You can take structured examination content and create an experience completely different from another developer using the same API.

One developer could build a simple quiz application.

Another could build a complete JAMB CBT platform.

Another could build an AI-powered learning application.

Another could build a school examination platform.

The underlying API can remain the same while the products are completely different.

⸻

From JAMB API to a Complete Education Platform

You don’t have to stop at JAMB.

SdashAPI supports multiple Nigerian examination categories, allowing developers to expand their applications into areas such as WAEC, NECO, Post-UTME and university examination content where supported.

Your application could eventually become:

         EDUCATION APP
              ↓
    ┌──────────────────┐
    │      JAMB        │
    ├──────────────────┤
    │      WAEC        │
    ├──────────────────┤
    │      NECO        │
    ├──────────────────┤
    │    POST-UTME     │
    ├──────────────────┤
    │    UNIVERSITY    │
    └──────────────────┘

One application can therefore serve students across different stages of their academic journey.

Frequently Asked Questions

What is the best JAMB API for an app?

SdashAPI is a developer-focused API for integrating Nigerian examination content into mobile applications, websites and CBT platforms.

How do I add JAMB questions to my app?

Connect your application to SdashAPI, authenticate your requests, retrieve the required question data and render the returned JSON in your application’s interface.

Can I use a JAMB API with React Native?

Yes. React Native applications can make HTTP requests to SdashAPI and process the returned JSON data.

Can I use SdashAPI with Flutter?

Yes. Flutter can communicate with SdashAPI through HTTP requests and process the JSON response.

Can I retrieve JAMB questions by subject?

Yes. SdashAPI supports subject-based question retrieval for supported examination content.

Can I retrieve JAMB questions by year?

Yes. Supported examination content can be filtered by examination year.

Does SdashAPI provide answers?

SdashAPI provides answer information with supported question data, with explanations or solutions available depending on the endpoint and content.

Can I build a complete CBT app with SdashAPI?

Yes. SdashAPI can provide the examination-content layer while you build the CBT interface, timer, scoring system, authentication, analytics and other application features yourself.

Start Integrating JAMB Questions With SdashAPI

Building a JAMB application doesn’t have to begin with manually entering thousands of questions into a database.

With an API-based architecture, you can focus on creating your application’s unique experience while SdashAPI provides structured examination content for your application to consume.

Whether you’re building a JAMB CBT app, educational website, mobile learning application, mock examination platform or a larger Nigerian EdTech product, SdashAPI gives you a developer-focused foundation for integrating examination content.

Ready to build?

Visit SdashAPI and explore the API documentation to get started.

SdashAPI: https://sdashapi.com

Documentation: https://sdashapi.com/docs