Question API by topic

A question API by topic allows developers to organise exam practice around specific areas of a subject instead of giving students questions from the entire syllabus at random.

For example, instead of:

UTME → Biology → 40 Random Questions

a student could practise:

UTME → Biology → Genetics
UTME → Biology → Ecology
UTME → Biology → Cell Biology

This is particularly useful for revision apps, personalised learning systems and CBT platforms that help students identify and improve weak areas.

SdashAPI provides richer question metadata through its advanced API versions, including topic and subtopic information where available.

What does topic data look like?

A normal question API might return:

{
  "id": 81294,
  "question": "Which of the following is responsible for photosynthesis?",
  "option": {
    "a": "Nucleus",
    "b": "Chloroplast",
    "c": "Ribosome",
    "d": "Mitochondrion"
  },
  "answer": "b"
}

A richer question record can additionally contain metadata:

{
  "metadata": {
    "topic": "Cell Biology",
    "subtopic": "Cell Organelles",
    "difficulty": "easy",
    "type": "MCQ",
    "skill": "Recall"
  }
}

Now your application understands what the question is actually testing.

Using the real SdashAPI V4 endpoint

According to the current SdashAPI Documentation, richer question information is available through V4:

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

Authentication uses the AccessToken header.

For example:

curl -X GET "https://sdashapi.com/api/v4/q?subject=biology&type=utme&year=2024" \
  -H "AccessToken: YOUR_ACCESS_TOKEN"

The important filters here are:

subject = biology
type    = utme
year    = 2024

V4 can then provide richer metadata around the returned questions, including topics and subtopics where available.

Before using a topic directly as a query parameter, however, check the current SdashAPI Documentation. A field being returned as metadata does not automatically mean the API accepts that same field as a server-side filter.

Building topic practice

Suppose your application receives Biology questions containing metadata such as:

Genetics
Ecology
Cell Biology
Evolution
Nutrition
Reproduction

You can organise them inside your application:

Biology

Choose a Topic

[ Genetics ]
[ Ecology ]
[ Cell Biology ]
[ Evolution ]
[ Nutrition ]

When the student selects Genetics, your application creates a practice session using questions classified under that topic.

Go deeper with subtopics

A single topic can still be very broad.

Consider Mathematics:

Algebra

With subtopics, you could provide:

Algebra
   ↓
Linear Equations
Quadratic Equations
Simultaneous Equations
Inequalities
Indices

This creates much more focused revision.

Instead of telling a student:

You are weak in Mathematics.

your platform could eventually tell them:

Your weakest area is Quadratic Equations.

That's far more useful.

Combine topics with difficulty

Topic metadata becomes even more useful when combined with difficulty information.

For example:

Subject: Biology
Topic: Genetics
Difficulty: Easy

or:

Subject: Biology
Topic: Genetics
Difficulty: Hard

Your application can then create progression such as:

Genetics

Easy
  ↓
Medium
  ↓
Hard

This makes it possible to build structured learning rather than simply showing random past questions.

Track performance by topic

Save each attempt against its question ID and associated metadata.

For example:

{
  "question_id": 81294,
  "topic": "Genetics",
  "selected_answer": "c",
  "correct": false,
  "time_spent": 48
}

After several sessions, your application can calculate:

BIOLOGY PERFORMANCE

Cell Biology       84%
Ecology            76%
Genetics           43%
Nutrition          81%
Reproduction       68%

Now you can clearly see that Genetics needs attention.

Build a "Weak Topics" feature

This is where topic-based question data becomes particularly useful.

Your backend could calculate:

if (topicAccuracy < 50) {
  weakTopics.push(topic);
}

The student's dashboard might then show:

Topics to Work On

1. Genetics
2. Evolution
3. Reproduction

[ Start Revision ]

Pressing Start Revision can generate another session containing questions from those areas.

The API provides the question metadata. Your own software decides how to use it.

Topic practice vs year practice

Both modes are useful, but they solve different problems.

Year-based practice answers:

What questions appeared in this examination year?

For example:

UTME
→ Biology
→ 2024

Topic-based practice answers:

What questions can help me practise this particular concept?

For example:

UTME
→ Biology
→ Genetics

A strong exam-preparation platform can offer both.

Use topic data for recommendations

Once you have enough student performance data, you can create personalised recommendations.

For example:

Recommended for You

You scored 42% in Genetics.

Practice:
• Mendelian Genetics
• Variation
• Heredity

You don't necessarily need AI to build the first version of this.

A straightforward rules-based recommendation system can already be useful:

Accuracy below 50%
        ↓
Mark topic as weak
        ↓
Recommend additional questions

Later, you can make the recommendation engine more sophisticated.

Topic data can improve search too

Instead of only allowing users to browse questions by examination and year, you can build a search experience around concepts.

For example:

Search: Photosynthesis

Biology
Plant Nutrition
Photosynthesis

23 Practice Questions

Or:

Search: Projectile Motion

Physics
Mechanics
Projectile Motion

[ Start Practice ]

This can make a large question bank considerably easier to explore.

SdashAPI as the question-data layer

A topic-based learning application could use this architecture:

Student
   ↓
Your App
   ↓
Your Backend
   ↓
SdashAPI V4
   ↓
Question + Topic + Subtopic + Metadata

Your backend can then use those fields for practice sessions, analytics and recommendations.

You can check the examinations and data currently available through SdashAPI Coverage.

Start with 2,000 free credits

Developers receive 2,000 free credits for development and testing, allowing you to work with real SdashAPI responses before paying for production usage.

You can use those credits to test:

• Topic metadata
• Subtopics
• Difficulty
• Question rendering
• Explanations
• Practice sessions
• Weak-topic tracking
• Performance analytics

Start with SdashAPI and use the SdashAPI Documentation to confirm the current V4 response fields and supported query parameters.

When the application is ready for real users, you can generate a separate production API key and review SdashAPI Pricing.

A question API by topic is most useful when the goal is not simply to give students more questions, but to give them the right questions. Topic and subtopic metadata can turn a basic CBT application into a system that identifies weak areas, creates focused revision sessions and tracks whether a student is actually improving.