# ExamTopics Scraper (`crawlerbros/examtopics-scraper`) Actor

Scrape free IT certification exam questions, answer choices, correct answers, and community vote tallies from examtopics.com - AWS, Microsoft, Cisco, CompTIA, Google, and 180+ other vendors.

- **URL**: https://apify.com/crawlerbros/examtopics-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## ExamTopics Scraper

Scrape free IT and professional certification exam questions from **examtopics.com** — AWS, Microsoft, Cisco, CompTIA, Google, PMI, ISACA, VMware, and 180+ other vendors. Get question text, answer choices, the correct answer, and the community's vote tally (which answer real test-takers actually chose) — no login required.

### What this actor does

- **Four modes:** `vendors`, `exams`, `searchExams`, `questions`
- **Vendors:** list all 188 exam providers on ExamTopics, with exam counts
- **Exams:** list every exam offered by a vendor (code + title + slug)
- **Search exams:** find exams by keyword across ALL vendors at once (e.g. `cloud practitioner`, `security+`) — mirrors ExamTopics' own site-wide exam search, useful when you don't already know which vendor an exam belongs to
- **Questions:** full question text, all answer choices, the marked correct answer, and the community vote breakdown (which choice was most-voted, and by how many people) for a specific exam
- **Filters:** topic number, multiple-answer-only, keyword search
- **Empty fields are omitted** — every field present in a record is guaranteed to have real data

### Output fields

#### Vendor (`recordType: "vendor"`)

| Field | Description |
|---|---|
| `vendorSlug` | URL slug, e.g. `amazon` |
| `vendorName` | Display name, e.g. `Amazon` |
| `examCount` | Number of exams ExamTopics lists for this vendor |
| `sourceUrl` | Vendor's exam-list page |

#### Exam (`recordType: "exam"`)

| Field | Description |
|---|---|
| `vendorSlug`, `examSlug` | URL identifiers |
| `examCode` | Exam code, e.g. `SAA-C03` |
| `examTitle` | Full exam title |
| `sourceUrl` | Exam's landing page |

#### Question (`recordType: "question"`)

| Field | Description |
|---|---|
| `questionId` | ExamTopics' internal numeric question id |
| `questionNumber` | Question's position within the exam |
| `topic` | Topic/section number (large exams are split into topics) |
| `vendorSlug`, `examSlug`, `examCode`, `examTitle` | Exam context |
| `questionText` | Full question text |
| `questionType` | `standard` (lettered choices), `hotspot`, `dragDrop`, or `simulation` — some exams (esp. Microsoft, AWS) use diagram-based question UIs instead of A/B/C/D choices |
| `questionImageUrl` | *(hotspot/dragDrop only)* The question's diagram image |
| `choices[]` | *(standard only)* `{letter, text}` for every answer option |
| `correctAnswer` | *(standard only)* The marked correct answer letter(s), e.g. `"C"` or `"AE"` for multi-select |
| `isMultipleChoice` | *(standard only)* `true` if more than one letter is correct (select-multiple question) |
| `correctAnswerImageUrl` | *(hotspot/dragDrop only)* The answer diagram image showing the correct placements |
| `answerDescription` | Explanation/reference text accompanying the answer, when ExamTopics provides one |
| `communityVotes[]` | *(standard only)* `{answer, voteCount, isMostVoted}` — real visitor votes on which answer they believe is correct |
| `discussionCount` | Number of community discussion comments on this question |
| `comments[]` | *(only when `includeComments` is enabled)* `{commentId, questionId, username, date, selectedAnswer, content, upvoteCount}` — real discussion comments |
| `sourceUrl` | The ExamTopics page the question was scraped from |

Every record also has `recordType` and `scrapedAt` (UTC ISO timestamp).

### Input

| Field | Type | Applies to | Description |
|---|---|---|---|
| `mode` | select | all | `questions` / `vendors` / `exams` / `searchExams` |
| `vendorSlug` | select | exams, questions | Exam vendor (188 options) |
| `examSearchQuery` | string | searchExams | Keyword(s) to find exams across all vendors, min 2 chars |
| `examSlug` | string | questions | Exam URL slug — look it up via `mode=exams` or `mode=searchExams` |
| `topicFilter` | integer | questions | Only emit questions from this topic number |
| `multipleChoiceOnly` | boolean | questions | Only emit "select multiple" questions (excludes HOTSPOT/drag-drop, which have no lettered answer) |
| `questionTypeFilter` | select | questions | Only emit `standard`, `hotspot`, `dragDrop`, or `simulation` questions |
| `containsKeyword` | string | questions | Case-insensitive match against question text / choices |
| `includeComments` | boolean | questions | Also fetch each question's discussion comments (adds one request per question) |
| `maxCommentsPerQuestion` | integer | questions | Cap on comments attached per question when `includeComments` is on (1–50, default 10) |
| `maxItems` | integer | all | Hard cap on emitted records (1–2000, default 50) |

#### Example: browse all vendors

```json
{ "mode": "vendors", "maxItems": 200 }
```

#### Example: list all AWS exams

```json
{ "mode": "exams", "vendorSlug": "amazon", "maxItems": 100 }
```

#### Example: search exams by keyword across all vendors

```json
{ "mode": "searchExams", "examSearchQuery": "cloud practitioner", "maxItems": 50 }
```

#### Example: AWS Cloud Practitioner questions

```json
{
  "mode": "questions",
  "vendorSlug": "amazon",
  "examSlug": "aws-certified-cloud-practitioner-clf-c02",
  "maxItems": 10
}
```

#### Example: multi-select questions only, filtered by keyword

```json
{
  "mode": "questions",
  "vendorSlug": "microsoft",
  "examSlug": "az-900",
  "multipleChoiceOnly": true,
  "containsKeyword": "storage",
  "maxItems": 10
}
```

#### Example: questions with discussion comments

```json
{
  "mode": "questions",
  "vendorSlug": "amazon",
  "examSlug": "aws-certified-cloud-practitioner-clf-c02",
  "includeComments": true,
  "maxCommentsPerQuestion": 5,
  "maxItems": 10
}
```

### Use cases

- **Exam-prep apps** — build a free practice-question bank across any certification track
- **Study tools** — surface the community's "most voted" answer alongside the official one to flag disputed questions
- **Content aggregation** — track new exam versions as vendors retire old certifications (e.g. SAA-C02 → SAA-C03)
- **EdTech research** — analyze question difficulty via vote-split (a near-even vote split usually signals an ambiguous or commonly-missed question)

### FAQ

**Do I need an ExamTopics account?**  No login, cookies, or API key needed for the data this actor returns.

**Why does `questions` mode cap out around 10 questions per exam?**  ExamTopics shows each exam's first 10 questions to anonymous visitors as a free preview; the remaining questions require a paid ExamTopics account to view. This actor only scrapes what's publicly accessible without logging in — it will never fabricate answers for the gated questions. Run it across many exams/vendors to build a broad free-tier question bank instead.

**Is the `correctAnswer` field the "official" answer or the "community" answer?**  It's ExamTopics' marked suggested answer (their site's `Correct Answer:` label). The separate `communityVotes` array shows how real visitors voted, which sometimes disagrees with the marked answer — check `isMostVoted` to see if the crowd agrees.

**What does `isMultipleChoice` mean?**  `true` when the correct answer has more than one letter (e.g. `"AE"`), meaning the original question said "select two" or similar.

**How are `topic` numbers used?**  Large or frequently-updated exams are sometimes split by ExamTopics into multiple topics (question sets). Most exams have a single `Topic 1`.

**How fresh is the data?**  ExamTopics adds and updates questions continuously as certifications change; since this actor scrapes live pages, results reflect the current site content on every run.

**What's in `comments[]`?**  When `includeComments` is enabled, each question record gets its real community discussion thread — username, the absolute comment date/time, the commenter's selected answer (if they voted), the comment text, and upvote count. This costs one extra HTTP request per question, so it's off by default.

**How is `searchExams` different from `exams`?**  `mode=exams` lists every exam for a vendor you already know (e.g. `vendorSlug: "amazon"`). `mode=searchExams` searches by keyword across ALL 188 vendors at once — use it when you know the exam name/code but not which vendor it belongs to (e.g. searching `"security+"` finds CompTIA's exam without you having to know the vendor slug is `comptia`).

**What are HOTSPOT / drag-drop questions?**  Some exams (frequently Microsoft's) use interactive question UIs — dropdown selections over a diagram (HOTSPOT) or matching items by dragging (DRAG DROP) — instead of lettered A/B/C/D choices. These questions don't have a `correctAnswer` letter or `choices[]`; instead you get `questionImageUrl` (the diagram), `correctAnswerImageUrl` (the answer key diagram), and often an `answerDescription` explaining the solution in text. Use `questionTypeFilter: "standard"` to skip them if your use case needs lettered MCQs only.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `examSearchQuery` (type: `string`):

Keyword(s) to find exams across ALL vendors, e.g. `cloud practitioner` or `security+`. Matches examtopics.com's own site-wide exam search. Required for `searchExams` mode (minimum 2 characters).

## `vendorSlug` (type: `string`):

Exam vendor/provider, e.g. Amazon, Microsoft, Cisco. Required for `exams` and `questions` modes.

## `examSlug` (type: `string`):

The specific exam's URL slug, e.g. `aws-certified-cloud-practitioner-clf-c02`. Find it via `mode=exams` first, or copy it from an examtopics.com exam URL. Required for `questions` mode. Note: ExamTopics only exposes each exam's first 10 questions to anonymous visitors (the rest require a paid login) — this actor reliably returns up to those 10 questions per exam.

## `topicFilter` (type: `integer`):

Only emit questions from this topic number (large exams are sometimes split into multiple topics/versions). Leave empty for all topics.

## `multipleChoiceOnly` (type: `boolean`):

Only emit questions that require selecting more than one correct answer (e.g. "Select TWO"). HOTSPOT/drag-drop questions are excluded since they have no letter-based answer to evaluate.

## `questionTypeFilter` (type: `string`):

Only emit questions of this UI type. Most exams are all `standard`; some (esp. Microsoft, AWS) include HOTSPOT or drag-and-drop questions where the answer is a diagram image instead of lettered choices.

## `containsKeyword` (type: `string`):

Only emit questions whose question text or answer choices contain this keyword (case-insensitive).

## `includeComments` (type: `boolean`):

Also fetch each question's community discussion comments (username, date, their selected answer, comment text, upvote count). Adds one extra request per question.

## `maxCommentsPerQuestion` (type: `integer`):

Cap on the number of discussion comments attached to each question when `includeComments` is enabled.

## `maxItems` (type: `integer`):

Hard cap on the number of records emitted. For mode=questions, ExamTopics only exposes ~10 free questions per exam to anonymous visitors, so higher values just mean "return all available questions" rather than exactly maxItems.

## Actor input object example

```json
{
  "mode": "questions",
  "examSearchQuery": "cloud practitioner",
  "vendorSlug": "amazon",
  "examSlug": "aws-certified-cloud-practitioner-clf-c02",
  "multipleChoiceOnly": false,
  "questionTypeFilter": "",
  "includeComments": false,
  "maxCommentsPerQuestion": 10,
  "maxItems": 50
}
```

# Actor output Schema

## `examData` (type: `string`):

Dataset containing all scraped vendors, exams, or questions.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "questions",
    "examSearchQuery": "cloud practitioner",
    "vendorSlug": "amazon",
    "examSlug": "aws-certified-cloud-practitioner-clf-c02",
    "multipleChoiceOnly": false,
    "questionTypeFilter": "",
    "includeComments": false,
    "maxCommentsPerQuestion": 10,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/examtopics-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "questions",
    "examSearchQuery": "cloud practitioner",
    "vendorSlug": "amazon",
    "examSlug": "aws-certified-cloud-practitioner-clf-c02",
    "multipleChoiceOnly": False,
    "questionTypeFilter": "",
    "includeComments": False,
    "maxCommentsPerQuestion": 10,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/examtopics-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "questions",
  "examSearchQuery": "cloud practitioner",
  "vendorSlug": "amazon",
  "examSlug": "aws-certified-cloud-practitioner-clf-c02",
  "multipleChoiceOnly": false,
  "questionTypeFilter": "",
  "includeComments": false,
  "maxCommentsPerQuestion": 10,
  "maxItems": 50
}' |
apify call crawlerbros/examtopics-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/examtopics-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ke0CC8MG3O9kOySab/builds/M0LkM21BCWZfFptLm/openapi.json