How Can I Fetch JAMB Questions and Answers in JSON Format?

If you're building a JAMB CBT app, UTME practice website, mobile learning application or examination platform, you can fetch JAMB questions and answers in JSON format using SdashAPI.

SdashAPI provides a REST API that allows developers to request structured JAMB/UTME examination questions and receive the results as JSON.

Instead of manually creating a database of questions, options, answers and explanations, your application can make an HTTP request to SdashAPI and process the returned JSON directly.

A basic request looks like this:

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

The API returns structured question data that your website, mobile application or backend can use.

What Is a JAMB Questions JSON API?

A JSON API allows your application to request JAMB examination content in a machine-readable format.

Instead of receiving something like a webpage:

<h2>Biology Question</h2>
<p>Which organelle is responsible for photosynthesis?</p>

you receive structured data similar to:

{
  "status": 200,
  "data": {
    "id": 12345,
    "question": "Which organelle is responsible for photosynthesis?",
    "option": {
      "a": "Nucleus",
      "b": "Chloroplast",
      "c": "Mitochondrion",
      "d": "Ribosome"
    },
    "answer": "b",
    "solution": "Photosynthesis takes place in the chloroplast.",
    "examtype": "UTME",
    "examyear": "2022"
  }
}

Your application can then access individual values such as:

data.question
data.option
data.answer
data.solution
data.examyear

This is what makes JSON particularly useful when building CBT applications.

Step 1: Create a SdashAPI Account

To fetch JAMB questions, first create a developer account with SdashAPI.

After registration, you'll receive access to your developer dashboard.

Your dashboard provides your personal Access Token.

This token authenticates your requests to SdashAPI.

For example:

AccessToken: YOUR_ACCESS_TOKEN

Replace YOUR_ACCESS_TOKEN with your actual SdashAPI token.

Step 2: Choose the JAMB Subject You Want

SdashAPI allows you to request questions by subject.

For example, if you need Biology:

subject=biology

For Chemistry:

subject=chemistry

For Physics:

subject=physics

For Mathematics:

subject=mathematics

You can combine the subject with other parameters to control the questions returned by the API.

Step 3: Specify JAMB/UTME as the Examination

For JAMB questions, specify the examination type as UTME:

type=utme

A request could therefore look like:

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

This tells SdashAPI that your application wants Biology questions associated with UTME.

Step 4: Filter JAMB Questions by Year

You can also specify an examination year.

For example:

year=2022

Combine everything:

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

Now your application is requesting:

Biology + UTME + 2022

This is particularly useful if your CBT application allows students to practise JAMB questions by year.

Step 5: Fetch Multiple Questions

You can use the limit parameter when your application needs multiple questions.

For example:

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

Your application can then use the returned data to create a complete practice session.

For example:

Biology
JAMB 2022
20 Questions

Students can answer each question while your application handles navigation, timing and scoring.

Fetch JAMB Questions With JavaScript

JavaScript developers can use the Fetch API.

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

  const data = await response.json();

  console.log(data);
}

getJambQuestions();

The important line is:

const data = await response.json();

This converts the HTTP response into a JavaScript object that your application can work with.

You can then access and display the questions in your interface.

Display the Question in JavaScript

Once you have the response, you can use the returned fields in your application.

Conceptually:

console.log(data.question);
console.log(data.option);
console.log(data.answer);
console.log(data.solution);

Your frontend can transform these values into a CBT interface.

For example:

Question 1

Which organelle is responsible for photosynthesis?

A. Nucleus
B. Chloroplast
C. Mitochondrion
D. Ribosome

[Next Question]

After the student submits the test, your application can compare their selected option against the correct answer returned by the API.

Fetch JAMB JSON Data With Python

Python developers can use the requests package.

import requests

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

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

headers = {
    "AccessToken": "YOUR_ACCESS_TOKEN"
}

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

data = response.json()

print(data)

The response is converted directly into a Python dictionary.

You can then process the questions, store selected information in your database or send the data to your frontend.

Fetch JAMB Questions With React Native

If you're building an Android or iOS CBT application with React Native:

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

    const json = await response.json();

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

You can then store the returned questions in your component or application state.

For example:

const [questions, setQuestions] = useState([]);

After fetching:

setQuestions(json.data);

Your React Native application can then render each question inside the CBT interface.

Can Flutter Fetch JAMB Questions as JSON?

Yes.

SdashAPI is a REST API, so Flutter can communicate with it using normal HTTP requests.

The same applies to:

JavaScript
TypeScript
React
React Native
Node.js
Flutter
Dart
Python
PHP
Laravel
Java
Kotlin
Swift
C#
Go

If your programming language can make an HTTPS request and parse JSON, it can communicate with SdashAPI.

What Information Can Be Included in the JSON?

Depending on the endpoint and SdashAPI version being used, question data can include information such as:

Question
Options
Correct answer
Solution
Section
Examination type
Examination year
Images where available
Topic
Subtopic
Difficulty
Tags
Passage information
Detailed explanations
Additional educational metadata

This is useful because different applications need different levels of information.

A simple CBT application may only require the question, options and correct answer.

A more advanced learning platform may want topics, subtopics, detailed explanations and related learning information.

SdashAPI V1 for Basic JSON Question Data

SdashAPI V1 is useful when your main requirement is retrieving the core information needed for a CBT application.

For example:

GET /api/v1/q

can be used to retrieve question data.

You can combine the endpoint with parameters such as:

subject=chemistry
type=utme
year=2022
limit=20

giving you:

/api/v1/q?subject=chemistry&type=utme&year=2022&limit=20

What About More Detailed JAMB JSON Data?

This is where the different SdashAPI versions become useful.

SdashAPI has V1, V2, V3 and V4 API structures for different levels of educational information.

For applications that need richer data, advanced versions can provide additional information around the question.

This can include areas such as:

Topic and subtopic classification

Your application can organise questions into areas such as:

Physics
└── Electricity
    └── Current Electricity

Detailed explanations

Instead of simply showing the correct answer, your application can provide educational explanations.

Common mistakes

More advanced educational interfaces can help students understand mistakes associated with a question.

Related questions

Your application can use related-question functionality to create further practice around concepts a student is struggling with.

This makes the API useful for more than traditional CBT applications.

Can I Build an AI Study App With the JSON?

Yes.

Structured JSON is particularly useful for AI-powered educational products.

For example, your application could fetch a question from SdashAPI and then use its metadata to build features such as:

Personalised revision
Weak-topic detection
Smart question recommendations
AI explanations
Adaptive CBT sessions
Student performance analysis
Topic mastery tracking

Instead of working with unstructured text copied from webpages, your application receives fields it can process programmatically.

Can I Get JAMB Novel Data in JSON?

SdashAPI also provides API functionality around educational novels.

This allows developers to build JAMB novel-study features alongside their regular CBT functionality.

Depending on the endpoint, your application can work with structured novel information and practice questions.

This means you could create one application containing:

JAMB Past Questions
+
CBT Practice
+
JAMB Novel
+
Novel Questions
+
Study Tools

while using SdashAPI as the educational data layer.

Do I Have to Scrape JAMB Questions From Websites?

No.

If your goal is simply to get structured examination data for your application, using an API is much cleaner than building a web scraper.

Scraping often requires you to:

Download HTML
Parse webpage elements
Remove unrelated content
Identify questions
Extract options
Match answers
Handle website layout changes
Convert everything into JSON
Maintain your own database

With SdashAPI, the data is already exposed through API endpoints and returned in a structured format.

Your application can concentrate on consuming the JSON.

Can I Store the JSON in My Own Database?

How you cache, store or reuse API data should follow the permissions and conditions of your specific SdashAPI plan or licence.

If your project requires bulk datasets, extensive offline access or a separate dataset licence, use the appropriate SdashAPI access option rather than assuming normal API access provides unrestricted database redistribution rights.

This is especially important for commercial CBT applications.

Is There a Free Way to Test the JAMB JSON API?

Yes.

SdashAPI provides developers with a Sandbox containing 2,000 API credits for testing.

You can use those credits to test your integration and understand the JSON response before moving your application to a larger production plan.

For example, you can test:

Authentication
Subject selection
Year filtering
Question retrieval
JSON parsing
Answer checking
CBT navigation
Score calculation
Frontend rendering

This means you can build a working prototype before committing to production usage.

Keep Your Access Token Private

Your SdashAPI Access Token should be treated as a private credential.

Avoid publishing it in:

GitHub repositories
Public code snippets
Tutorials
Frontend source code
Public configuration files

For production mobile and web applications, consider making requests through your backend:

Your CBT App
      ↓
Your Backend/API
      ↓
SdashAPI
      ↓
JAMB JSON Data

Your backend keeps your Access Token private while your application receives only the information it needs.