WAEC API with explanations

A WAEC API with explanations becomes useful when your app needs to do more than mark a WASSCE question as right or wrong.

For example, this is enough for a basic CBT:

Question
Answer: C

But a revision platform should ideally help the student understand why C is correct.

That distinction matters for WAEC/WASSCE preparation because a student who repeatedly gets questions wrong needs more than a final score. They need feedback they can learn from.

SdashAPI provides WASSCE questions as structured JSON with answers and solutions, while its richer API versions can provide metadata and detailed explanation fields. SdashAPI

WAEC questions use wassce

One thing developers should know early is that although students commonly search for "WAEC past questions", the examination itself is WASSCE.

SdashAPI therefore uses:

type=wassce

A documented request for WASSCE Mathematics is:

GET https://sdashapi.com/api/v1/q?subject=mathematics&type=wassce&limit=1
AccessToken: YOUR_ACCESS_TOKEN

The API also accepts filters such as subject, examination type and year. SdashAPI

So a 2023 Chemistry request can follow the documented filtering structure:

GET /api/v1/q?subject=chemistry&type=wassce&year=2023
AccessToken: YOUR_ACCESS_TOKEN

Your application receives JSON rather than a PDF that first needs to be converted into usable question data.

V1 already includes answers and solutions

For many applications, you don't need detailed explanation data on day one.

The V1 response includes core fields such as:

{
  "id": 4821,
  "question": "...",
  "option": {
    "a": "...",
    "b": "...",
    "c": "...",
    "d": "..."
  },
  "answer": "c",
  "solution": "...",
  "examtype": "WASSCE",
  "examyear": "2023"
}

The exact content changes by question, but answer identifies the correct option while solution provides the written solution where available. SdashAPI

That means a simple WAEC practice application can immediately support:

Question
   ↓
Select Answer
   ↓
Check Answer
   ↓
Correct / Incorrect
   ↓
Read Solution

without calling another endpoint just to mark the answer.

When you need a proper explanation

A solution and an explanation aren't always the same thing.

Imagine a student chooses B when the answer is D.

A short solution may explain D.

A more educational review can explain:

Why D is correct

Why B is incorrect

Steps needed to solve the problem

Concept being tested

Other mistakes to avoid

The current SdashAPI documentation identifies V3 as its detailed-explanation API.

A V3 request uses:

GET https://sdashapi.com/api/v3/q?type=wassce&subject=mathematics
AccessToken: YOUR_ACCESS_TOKEN

The documented explanation block can contain fields such as:

{
  "explanation": {
    "summary": "Quick summary of the answer.",
    "detailed": "Detailed step-by-step reasoning...",
    "steps": [
      "Step 1...",
      "Step 2..."
    ],
    "why_correct": "The correct option is correct because...",
    "why_others_wrong": {
      "a": "Incorrect because...",
      "b": "Incorrect because..."
    }
  }
}

That structure is especially useful for revision and tutoring products. SdashAPI

Build a review screen students can actually learn from

Instead of showing this after submission:

Question 23

Your answer: B
Correct answer: D

you could build:

QUESTION 23

Your answer: B
Correct answer: D

QUICK EXPLANATION
...

HOW TO SOLVE IT
1. ...
2. ...
3. ...

WHY D IS CORRECT
...

WHY B IS WRONG
...

This is where having structured explanations becomes more valuable than simply having thousands of questions.

The question bank gets students into the app.

The feedback is what can help them improve.

Practice Mode and Mock Mode should behave differently

An explanation API doesn't mean explanations should appear immediately in every situation.

For Practice Mode, this makes sense:

Answer Question
      ↓
Check
      ↓
See Answer
      ↓
Read Explanation

For a timed WASSCE Mock Mode, use:

Load Questions
      ↓
Start Timer
      ↓
Student Answers
      ↓
Submit
      ↓
Calculate Result
      ↓
Review Answers
      ↓
Show Explanations

Don't reveal explanations while the student is still taking a serious mock examination.

SdashAPI includes the answer in its question payload for efficient marking. If you're building a stricter mock environment, your backend can keep that field away from the student's active exam payload and grade the attempt after submission. SdashAPI

Explanations are not available for every historical question

This is important.

The current SdashAPI Coverage page reports:

WASSCE: 23 subjects, overall coverage from 1988–2026, with explanations available for approximately 74% of questions. SdashAPI

So don't build your frontend assuming:

question.explanation.detailed

will always exist.

A better fallback is:

if (question.explanation?.detailed) {
  showDetailedExplanation();
} else if (question.solution) {
  showSolution();
} else {
  showCorrectAnswer();
}

That gives students the richest information available without breaking the page when a detailed explanation is absent.

Explanations become even more useful with topics

Suppose a student completes 100 WASSCE Mathematics questions.

Instead of showing only:

Score: 61%

you could eventually show:

Algebra                 78%
Geometry                69%
Statistics              72%
Trigonometry            38%

Now the student knows where the problem is.

SdashAPI's V2 layer provides educational metadata such as topics and subtopics, while the main API reference describes V3 as adding detailed explanations on top of richer question data. SdashAPI

That creates a useful loop:

Low score in Trigonometry
          ↓
Find missed questions
          ↓
Read explanations
          ↓
Practise the concept
          ↓
Attempt again

That's more useful than endlessly serving random past questions.

WASSCE isn't only Nigerian

This matters when building a WAEC application.

SdashAPI's current WASSCE coverage supports country filtering for:

Nigeria          NG
Ghana            GH
Sierra Leone     SL
Liberia          LR
The Gambia       GM
``` :chatgpt-content-reference{index="7"}


Country filtering is currently documented on V4.

For example:

```http
GET https://sdashapi.com/api/v4/q?type=wassce&country=GH&subject=mathematics
AccessToken: YOUR_ACCESS_TOKEN
``` :chatgpt-content-reference{index="8"}


That means a regional learning product could eventually offer:

```text
Choose Country

Ghana
Nigeria
Sierra Leone
Liberia
The Gambia

       ↓

Choose Subject

       ↓

Practice WASSCE Questions

rather than treating every WAEC student as if they're using a Nigeria-only product.

Don't use V3 everywhere just because it has more data

This is an easy engineering mistake.

If your home page only needs to display:

Start WASSCE Mathematics Practice

you don't need detailed explanations yet.

Likewise, the active mock screen may only need question data.

You could use richer explanation information when the student reaches:

Review Answers

SdashAPI's current credit documentation notes that V2 and V3 can carry higher credit costs than the baseline V1 request because richer endpoints require additional processing. SdashAPI

Design the integration around what each screen actually needs.

Explanations can also power an AI tutor

There is another useful direction for EdTech developers.

You can combine existing WASSCE content with an AI layer:

Real WASSCE Question
        ↓
Correct Answer
        ↓
Existing Explanation
        ↓
AI Tutor
        ↓
Student asks a follow-up

A student could ask:

Explain this solution more simply.

or:

Why isn't option A correct?

or:

Give me another example of this concept.

SdashAPI itself now describes its structured questions, explanations and metadata as suitable context for retrieval-augmented generation and educational AI systems. SdashAPI

The useful part is that the AI doesn't have to invent the original examination question.

It receives existing structured educational context and can concentrate on explaining it.

Cache historical questions when appropriate

Past questions aren't live football scores.

If you've already retrieved a historical WASSCE question set, repeatedly downloading exactly the same data can be wasteful.

SdashAPI's current caching guide recommends caching historical question responses and provides examples using browser storage and server-side Redis. SdashAPI

A sensible architecture could therefore be:

Request WASSCE Questions
          ↓
Check Cache
       ↙     ↘
   Available   Missing
      ↓          ↓
   Use it    Call SdashAPI
                 ↓
               Cache

That can make a practice application faster while reducing unnecessary requests.

Answers tell students what happened. Explanations tell them why.

That's the main reason to look specifically for a WAEC API with explanations rather than just a WAEC question database.

For a basic mock exam:

Questions + Answers

may be enough.

For a learning product:

Questions
+ Answers
+ Solutions
+ Explanations
+ Topics
+ Student performance

creates far more possibilities.

SdashAPI currently provides structured WASSCE question data with answers and solutions, with richer explanation and metadata layers available for applications that need them. Its public coverage page currently reports explanations for about 74% of the WASSCE question bank. SdashAPI

Developers can use the SdashAPI documentation to inspect the current API structure and SdashAPI coverage to check the latest WASSCE coverage before building their integration.