# Brazil Exams Questions - API — ENEM, FUVEST, ITA, IME, UEM (`antonio_cesar/brazil-exams-questions-api-enem-fuvest-ita-ime-uem`) Actor

Query Brazilian educational exam questions by institution, year, topic, and video availability. Ideal for edtechs, mock exam platforms, study apps, educational bots, and content curation tools.

- **URL**: https://apify.com/antonio\_cesar/brazil-exams-questions-api-enem-fuvest-ita-ime-uem.md
- **Developed by:** [Antônio César](https://apify.com/antonio_cesar) (community)
- **Categories:** Videos, Integrations, Other
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 for each question 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/platform/actors/running/actors-in-store#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

### What does Brazil Exam Questions API do?

**Brazil Exam Questions API** helps you find Brazilian educational and exam questions by subject, institution, or question ID. Use the no-code Input form to collect structured results in an Apify Dataset, or connect your application to the Standby HTTP API.

The Actor runs on the [Apify platform](https://apify.com/), giving you API access, monitoring, integrations, scheduling, and downloadable datasets without maintaining your own scraping infrastructure.

> **Standby mode notice:** This Actor remains running after a successful initial search so the HTTP API stays available. If a selected initial search returns no results, the Actor stops automatically. When the API remains online, stop the Actor manually in Apify Console when you no longer need it; platform usage costs continue while the run is active.

### Why use Brazil Exam Questions API?

Use the Actor to build study applications, question banks, educational dashboards, revision tools, content catalogs, and research workflows. Results are returned as predictable JSON and can include the question statement, alternatives, institution, year, main topic, solution, images, and videos when available.

You can start with the visual Input form and later integrate the same workflow into Python, JavaScript, Make, Zapier, webhooks, or another Apify-compatible tool.

The image above shows one example of how structured exam data can power an interactive study experience. You can use the API to create:

- **Mobile study apps** with question navigation, timers, bookmarks, and answer review.
- **ENEM preparation platforms** organized by subject, year, institution, and main topic.
- **Question banks** for teachers, schools, courses, and educational publishers.
- **Practice tests and mock exams** assembled from filtered question collections.
- **Learning dashboards** that combine questions, solutions, images, and videos.
- **AI-assisted study tools** that use structured question data for explanations and personalized practice.
- **Academic research datasets** for analyzing subjects, institutions, years, and exam patterns.

### How to use Brazil Exam Questions API

1. Open the Actor in Apify Console.
2. Open the section for each data type you want to retrieve.
3. Enter a question, topic, institution, or question ID in the corresponding search field.
4. Configure the pagination and result limit shown in that section. A section runs when its search field is filled.
5. Click **Start**.
6. Open the Output or Dataset tab to inspect and download the results.

For direct integrations, start the Actor in Standby mode and use the container URL shown in its Output. For example:

```text
GET /api/questions?page=1&per_page=100
GET /api/questions/main-topics?search=Matem%C3%A1tica
GET /api/questions/institutions?search=ENEM
GET /api/questions/4000004207
GET /api/test
```

### Input

The Input tab supports the following fields:

| Field | Description | Default |
| --- | --- | --- |
| `questionInstitution` | Exact institution filter, such as ENEM | Empty |
| `questionYear` | Question year | Empty |
| `questionMainTopicName` | Partial main-topic filter, such as Matemática or MMC | Empty |
| `questionHasVideo` | All questions, with video, or without video | All |
| `topicSearchTerm` | Text used only for main-topic searches | Empty |
| `institutionSearchTerm` | Text used only for institution searches | Empty |
| `questionId` | Identifier used in Question by ID mode | Empty |
| `questionsPage`, `topicsPage` | Initial page for the corresponding search | `1` |
| `questionsPerPage`, `topicsPerPage` | Results requested per page, from 1 to 100 | `100` |
| `questionsMaxItems`, `topicsMaxItems`, `institutionsMaxItems` | Maximum Dataset results for the corresponding search | `1000` |

Example:

```json
{
  "questionInstitution": "ENEM",
  "questionYear": 2024,
  "questionMainTopicName": "Matemática",
  "questionHasVideo": "true",
  "questionsPerPage": 20,
  "questionsPage": 1,
  "questionsMaxItems": 1000
}
```

### Output

Input-form searches are saved progressively to the run's default Dataset. A representative question item looks like this:

```json
{
  "question_id": "4000004207",
  "main_topic_name": "Matemática",
  "institution": "ENEM",
  "year": 2024,
  "has_video": true,
  "question_json": {},
  "detail_json": {},
  "solution_json": {},
  "images_json": [],
  "videos_json": [],
  "price_usd": 0.1
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. The Standby API returns JSON directly over HTTP.

### Data table

| Field | Description |
| --- | --- |
| `question_id` | Unique question identifier |
| `main_topic_name` | Main educational topic |
| `institution` | Exam institution, such as ENEM |
| `year` | Exam year |
| `question_json` | Question statement, alternatives, and metadata |
| `detail_json` | Additional question details |
| `solution_json` | Solution or explanation when available |
| `images_json` | Related image objects |
| `videos_json` | Related video objects |
| `has_video` | Whether a video is available |
| `price_usd` | Base custom-event price before tier discounts and the Dataset event |

### How much does it cost to retrieve Brazilian exam questions?

The Actor uses pay-per-event pricing. Each question saved to the default Dataset triggers `question-result`, plus the automatic Dataset item event.

| Buyer tier | Question event / 1,000 | Dataset event / 1,000 | Effective total / 1,000 |
| --- | ---: | ---: | ---: |
| No discount | USD 100.00 | USD 1.00 | **USD 101.00** |
| Bronze | USD 68.33 | USD 1.00 | **USD 69.33** |
| Silver | USD 36.67 | USD 1.00 | **USD 37.67** |
| Gold | USD 5.00 | USD 1.00 | **USD 6.00** |

Main-topic and institution results cost **USD 5.00 per 1,000 items**, plus **USD 1.00 per 1,000 default Dataset items**. Actor start costs **USD 0.00005 per start unit**. Platform usage is charged separately. Your maximum charge per run is respected automatically by Apify.

### Tips and advanced options

- Start with a small maximum-results value in the selected search section while evaluating the data.
- Search main topics or institutions first when you do not know the exact available name.
- Use 100 items per page in the selected search section for fewer requests during larger collections.
- Use Question by ID when you need one known record instead of a paginated search.
- Configure a maximum run charge in Apify Console to control spending.

### Use cases for Brazil Exam Questions API

<p align="center">
  <img src="./image-example-app.png" alt="Example mobile study application powered by Brazil Exam Questions API" width="100%">
</p>

### FAQ, disclaimers, and support

#### Do I need programming experience?

No. You can run searches entirely through the Apify Input form and download the resulting Dataset.

#### Can I use the results through an API?

Yes. You can access Dataset results through the Apify API or use the Actor's Standby HTTP routes for direct integrations.

#### Why might some fields be empty?

Available details depend on the source record. Some questions may not contain solutions, images, or videos.

#### Is using educational question data legal?

You are responsible for ensuring that your use of the returned content complies with applicable copyright, licensing, privacy, institutional, and local legal requirements. This Actor does not grant ownership or redistribution rights over third-party content.

For bugs, missing data, or feature requests, open the Actor's **Issues** tab on Apify. Custom integrations and tailored data workflows are also available on request.

# Actor input Schema

## `questionInstitution` (type: `string`):

Exact institution name as registered. For example: ENEM.

## `questionYear` (type: `integer`):

Year in which the question appeared. For example: 2024.

## `questionMainTopicName` (type: `string`):

Partial main-topic name. For example: Matemática, MMC, or Regra de três.

## `questionHasVideo` (type: `string`):

Return all questions, only questions with video, or only questions without video.

## `questionsPerPage` (type: `integer`):

Number of question results per page. The Basic plan may limit this value to 50.

## `questionsPage` (type: `integer`):

First question-results page to retrieve.

## `questionsMaxItems` (type: `integer`):

Maximum number of questions saved to the Dataset during this run.

## `topicSearchTerm` (type: `string`):

Optional partial main-topic name. For example: Matemática.

## `topicsPerPage` (type: `integer`):

Number of main-topic results per page. The Basic plan may limit this value to 50.

## `topicsPage` (type: `integer`):

First main-topic results page to retrieve.

## `topicsMaxItems` (type: `integer`):

Maximum number of main topics saved to the Dataset during this run.

## `institutionSearchTerm` (type: `string`):

Optional partial institution name. For example: ENEM.

## `institutionsMaxItems` (type: `integer`):

Maximum number of institutions saved to the Dataset during this run.

## `questionId` (type: `string`):

Exact unique question identifier. For example: 12345.

## Actor input object example

```json
{
  "questionInstitution": "",
  "questionMainTopicName": "",
  "questionHasVideo": "",
  "questionsPerPage": 20,
  "questionsPage": 1,
  "questionsMaxItems": 1000,
  "topicSearchTerm": "",
  "topicsPerPage": 20,
  "topicsPage": 1,
  "topicsMaxItems": 1000,
  "institutionSearchTerm": "",
  "institutionsMaxItems": 1000,
  "questionId": ""
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `api` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("antonio_cesar/brazil-exams-questions-api-enem-fuvest-ita-ime-uem").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("antonio_cesar/brazil-exams-questions-api-enem-fuvest-ita-ime-uem").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 '{}' |
apify call antonio_cesar/brazil-exams-questions-api-enem-fuvest-ita-ime-uem --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,antonio_cesar/brazil-exams-questions-api-enem-fuvest-ita-ime-uem"
        }
    }
}

```

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/hqhYKqS90l4fbTbpO/builds/coaYEsiWiz1psYZD7/openapi.json