NECO question database JSON

A NECO question database JSON gives developers a structured way to use NECO past questions inside CBT apps, school portals, revision websites and educational software.

Instead of keeping questions in PDFs or Word documents, JSON separates each question into fields your application can understand:

{
  "id": 8931,
  "question": "Question text...",
  "option": {
    "a": "Option A",
    "b": "Option B",
    "c": "Option C",
    "d": "Option D"
  },
  "answer": "b",
  "solution": "Explanation or solution...",
  "image": null,
  "examtype": "NECO",
  "examyear": "2024"
}

This makes the data immediately useful for automatic marking, question navigation, revision history, analytics and other CBT features.

SdashAPI currently provides NECO question data through the same REST API infrastructure it uses for UTME, WASSCE and Post-UTME. Its current coverage page lists 25 NECO subjects, with an overall year range of 1988–2026. SdashAPI

Why JSON matters for a NECO app

Suppose you have this:

NECO Biology 2023.pdf

A student can read it, but your software doesn't automatically know which text is a question, where its options are, which answer is correct or which year and subject belong to it.

A JSON database solves that.

Your application can simply read:

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

Then your interface can turn those fields into a proper CBT screen.

That is the main difference between having NECO past questions and having a NECO question database.

Fetch NECO questions as JSON

SdashAPI's current core endpoint is:

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

Authentication uses an AccessToken header. The API documentation lists neco as one of the valid values for the type parameter. SdashAPI

For example, the current SdashAPI PHP documentation uses this exact NECO Chemistry request:

GET https://sdashapi.com/api/v1/q?type=neco&subject=chemistry
AccessToken: YOUR_ACCESS_TOKEN
``` :chatgpt-content-reference{index="2"}


So you don't need a separate API architecture just because you're adding NECO.

Your application could use:

```text
type=utme
type=wassce
type=neco
type=post-utme

depending on what the student selects. SdashAPI

Add year and number of questions

A useful CBT app will usually need more than a random question.

For example, a student might select:

NECO
Chemistry
2024
40 Questions

SdashAPI's documented filtering system allows subject, type, year and limit to be combined in one request. SdashAPI

Following that documented structure, your NECO request becomes:

GET https://sdashapi.com/api/v1/q?subject=chemistry&type=neco&year=2024&limit=40
AccessToken: YOUR_ACCESS_TOKEN

The API supports a maximum of 50 questions in one request. If you need 100 questions, the documentation recommends splitting them across requests rather than requesting all 100 at once. SdashAPI

Build one CBT engine instead of a separate NECO app

This is where structured JSON becomes particularly useful.

You don't necessarily need:

JAMB CBT Engine
WAEC CBT Engine
NECO CBT Engine

You can build one reusable engine:

Choose Exam
     ↓
Choose Subject
     ↓
Choose Year
     ↓
Fetch JSON
     ↓
Load CBT Engine

Then the examination type simply changes the data being requested.

Your React or Flutter question component doesn't particularly care whether the record came from NECO or UTME.

It needs predictable fields such as:

question
options
id
image

This makes expanding an existing exam-preparation app much easier.

Use IDs, not question positions

Every SdashAPI question has a unique integer id. The API also supports retrieving an individual question by its ID:

GET https://sdashapi.com/api/v1/q?id=8931
``` :chatgpt-content-reference{index="6"}


That becomes useful when storing student activity.

Instead of:

```javascript
answers[5] = "c";

you can use:

answers[8931] = "c";

Now question order can change without destroying the relationship between the student's answer and the actual question.

The ID can also support:

Bookmarks
Questions I Got Wrong
Attempt History
Revision Lists
Reported Questions

That small database decision becomes very important once your application has thousands of users.

Don't send answers carelessly during a mock exam

Your stored question object may contain:

{
  "answer": "b",
  "solution": "..."
}

That's useful for marking and revision.

But during a serious NECO mock exam, you probably don't want the correct answer sitting openly inside the active frontend state where it can easily be inspected.

A better architecture is:

SdashAPI
   ↓
Your Backend
   ↓
Remove answer + solution
   ↓
Student's Mock Exam
   ↓
Submit Answers
   ↓
Backend Marks Attempt
   ↓
Return Score + Review

For a simple practice app, keeping everything client-side may be acceptable. For a controlled school examination or competitive mock platform, server-side marking is a better design.

NECO JSON can contain more than questions and answers

SdashAPI has four question API versions.

The current documentation describes them broadly as:

V1 → Core question data
V2 → Metadata and taxonomy
V3 → Detailed explanations
V4 → Intelligence / similar-question features
``` :chatgpt-content-reference{index="7"}


V2 can add metadata such as:

```json
{
  "metadata": {
    "topic": "Organic Chemistry",
    "subtopic": "Alkanes",
    "difficulty": "medium",
    "type": "MCQ",
    "skill": "Recall",
    "tags": [
      "hydrocarbons",
      "covalent"
    ]
  }
}
``` :chatgpt-content-reference{index="8"}


That can turn a basic NECO question database into something more useful.

Instead of only offering:

> NECO Chemistry 2024

your application can eventually build features around topics, difficulty and student weaknesses.

## Explanations can also be structured

For revision apps, an answer such as:

> Correct answer: B

isn't always enough.

SdashAPI V3 adds a structured explanation object containing fields such as:

```json
{
  "explanation": {
    "summary": "Quick explanation...",
    "detailed": "Detailed reasoning...",
    "steps": [
      "Step 1...",
      "Step 2..."
    ],
    "why_correct": "Why the answer is correct...",
    "why_others_wrong": {
      "a": "Why A is wrong...",
      "c": "Why C is wrong..."
    }
  }
}
``` :chatgpt-content-reference{index="9"}


That allows a NECO revision app to go beyond scoring.

A student can answer incorrectly and immediately learn what went wrong.

## How much NECO data is available?

According to the current [SdashAPI Coverage](https://sdashapi.com/coverage) page, NECO currently has:

```text
25 subjects
1988–2026 overall year range
67% explanations
Images available
V1, V2, V3 and V4 support
``` :chatgpt-content-reference{index="10"}


The same page currently reports **368,868+ questions across the entire SdashAPI database**, covering all supported examination types. :chatgpt-content-reference{index="11"}

The 1988–2026 figure is an overall NECO coverage range. Developers shouldn't interpret it as meaning that every subject necessarily has questions available for every year.

Your interface should handle an unavailable combination gracefully.

## API JSON vs owning the complete NECO JSON dataset

There are two different things developers often mean when searching for a "NECO question database JSON."

### Using an API

Your architecture looks like:

```text
App
 ↓
Your Backend
 ↓
SdashAPI
 ↓
JSON Response

You request the data you need when you need it.

This is convenient because you don't have to maintain the entire question bank yourself.

Owning an offline dataset

Your architecture becomes:

NECO Dataset
    ↓
JSON / SQL
    ↓
Your Database
    ↓
Your Application

This may make more sense for completely offline CBT software, large institutional systems or products that need their own local copy.

SdashAPI currently advertises bulk dataset licensing in JSON, CSV, SQL and other formats for teams that need the full dataset offline. SdashAPI

So decide which requirement you actually have before building.

Can you test NECO for free?

There is an important limitation here.

SdashAPI currently provides 2,000 free Sandbox credits, but the current Sandbox plan lists only UTME and WASSCE with V1 access. NECO isn't currently listed as part of the free Sandbox. SdashAPI

The current Developer plan includes:

UTME
WASSCE
NECO
Post-UTME

along with 350,000 monthly API credits. SdashAPI

That's worth knowing before designing your development budget rather than assuming that every examination type is included in the free tier.

A good NECO database should be designed for software, not just storage

Having 50,000 questions isn't very useful if your application can't reliably determine:

Which exam is this?
Which subject?
Which year?
What are the options?
What's the correct answer?
Is there a solution?
Does it require an image?
What's its unique ID?

That structure is what turns a collection of past questions into usable educational infrastructure.

For developers who want API access, the current SdashAPI documentation shows the actual endpoints, filters and JSON responses, while SdashAPI Coverage shows the current NECO coverage.

A NECO question database JSON ultimately gives your software something a PDF cannot: past questions that can be searched, filtered, marked, analysed and reused programmatically.