# Loterias Caixa Economica Federal (`rafaelmcp/loteriascef`) Actor

Scrapper para dados de sorteios das loterias da Caixa Econômica Federal (Brasil).

- **URL**: https://apify.com/rafaelmcp/loteriascef.md
- **Developed by:** [Rafael Pereira](https://apify.com/rafaelmcp) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Caixa Loterias Scraper Apify Actor (Python)

This Apify Actor scrapes results of lottery draws from Caixa Econômica Federal.

### Features

- Scrapes the latest results by default.
- Allows fetching specific contest numbers for individual lotteries.
- Supports **10 major lotteries**:
  - Mega-Sena
  - Quina
  - Lotofácil
  - Lotomania
  - Dia de Sorte
  - + Milionária
  - Dupla Sena
  - Timemania
  - Super Sete
  - Loteca
- Outputs detailed draw information (including contest number, draw date, numbers drawn, payouts, and accumulated values) directly into the default Apify Dataset.

### Input Configuration

The Actor accepts a JSON object with the following properties:

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `modality` | String | The lottery modality to scrape (e.g., `megasena`, `quina`, `lotofacil`, `lotomania`, `diadesorte`, `maismilionaria`, `duplasena`, `timemania`, `supersete`, `loteca`). | `"megasena"` |
| `contest` | Integer | Specific contest number. If empty or 0, the latest draw is retrieved. | `0` |

#### Example Input

```json
{
  "modality": "megasena",
  "contest": 0
}
````

### Running Locally

To run this Actor locally:

1. Clone or copy the project files to your machine.
2. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```
3. Run the Python module to execute:
   ```bash
   python -m src
   ```
   Or if you have the Apify CLI installed:
   ```bash
   apify run
   ```

### Output Format

The scraped data is saved to the default dataset. Example of a saved dataset item:

```json
{
  "success": true,
  "lottery": "megasena",
  "contest": 3026,
  "date": "02/07/2026",
  "scraped_at": "2026-07-03T11:58:27.123456Z",
  "data": {
    "numero": 3026,
    "dataApuracao": "02/07/2026",
    "dezenasSorteadasOrdemSorteio": ["05", "18", "22", "35", "41", "56"],
    ...
  }
}
```

## \*\*\*\*\* EM PORTUGUÊS \*\*\*\*\*

## Scraper das Loterias da Caixa - Apify Actor (Python)

Este Apify Actor extrai resultados dos sorteios das loterias da Caixa Econômica Federal.

### Recursos

- Extrai os resultados mais recentes por padrão.
- Permite buscar números de concursos específicos para loterias individuais.
- Suporta **10 principais loterias**:
  - Mega-Sena
  - Quina
  - Lotofácil
  - Lotomania
  - Dia de Sorte
  - - Milionária
  - Dupla Sena
  - Timemania
  - Super Sete
  - Loteca
- Grava informações detalhadas do sorteio (incluindo número do concurso, data do sorteio, dezenas sorteadas, premiações e valores acumulados) diretamente no Apify Dataset padrão.

### Configuração de Entrada

O Actor aceita um objeto JSON com as seguintes propriedades:

| Campo | Tipo | Descrição | Padrão |
|-------|------|-------------|---------|
| `modality` | String | A modalidade de loteria a ser coletada (ex: `megasena`, `quina`, `lotofacil`, `lotomania`, `diadesorte`, `maismilionaria`, `duplasena`, `timemania`, `supersete`, `loteca`). | `"megasena"` |
| `contest` | Integer | Número de concurso específico. Se vazio ou 0, obtém o mais recente. | `0` |

#### Exemplo de Entrada

```json
{
  "modality": "megasena",
  "contest": 0
}
```

### Executando Localmente

Para executar este Actor localmente:

1. Clone ou copie os arquivos do projeto para sua máquina.
2. Instale as dependências:
   ```bash
   pip install -r requirements.txt
   ```
3. Execute o módulo Python para rodar:
   ```bash
   python -m src
   ```
   Ou, se você tiver a CLI do Apify instalada:
   ```bash
   apify run
   ```

### Formato de Saída

Os dados extraídos são salvos no dataset padrão. Exemplo de um item do dataset salvo:

```json
{
  "success": true,
  "lottery": "megasena",
  "contest": 3026,
  "date": "02/07/2026",
  "scraped_at": "2026-07-03T11:58:27.123456Z",
  "data": {
    "numero": 3026,
    "dataApuracao": "02/07/2026",
    "dezenasSorteadasOrdemSorteio": ["05", "18", "22", "35", "41", "56"],
    ...
  }
}
```

# Actor input Schema

## `modality` (type: `string`):

The lottery modality to scrape.
Em português: A modalidade de loteria a ser coletada.

## `contest` (type: `integer`):

Specific contest number. If empty or 0, the latest draw is retrieved.
Em português: Número do concurso específico. Se estiver vazio ou 0, o último sorteio é recuperado.

## Actor input object example

```json
{
  "modality": "megasena",
  "contest": 0
}
```

# Actor output Schema

## `results` (type: `string`):

The dataset containing all scraped lottery results.
Em português: O dataset contendo todos os resultados de loterias coletados.

# 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("rafaelmcp/loteriascef").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("rafaelmcp/loteriascef").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 rafaelmcp/loteriascef --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=rafaelmcp/loteriascef",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Loterias Caixa Economica Federal",
        "description": "Scrapper para dados de sorteios das loterias da Caixa Econômica Federal (Brasil).",
        "version": "0.0",
        "x-build-id": "xQdC4KpVXwCrE6oAC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rafaelmcp~loteriascef/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rafaelmcp-loteriascef",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/rafaelmcp~loteriascef/runs": {
            "post": {
                "operationId": "runs-sync-rafaelmcp-loteriascef",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/rafaelmcp~loteriascef/run-sync": {
            "post": {
                "operationId": "run-sync-rafaelmcp-loteriascef",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "modality"
                ],
                "properties": {
                    "modality": {
                        "title": "Modality",
                        "enum": [
                            "megasena",
                            "quina",
                            "lotofacil",
                            "lotomania",
                            "diadesorte",
                            "maismilionaria",
                            "duplasena",
                            "timemania",
                            "supersete",
                            "loteca"
                        ],
                        "type": "string",
                        "description": "The lottery modality to scrape.\nEm português: A modalidade de loteria a ser coletada.",
                        "default": "megasena"
                    },
                    "contest": {
                        "title": "Contest Number",
                        "type": "integer",
                        "description": "Specific contest number. If empty or 0, the latest draw is retrieved.\nEm português: Número do concurso específico. Se estiver vazio ou 0, o último sorteio é recuperado.",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
