# GuiaMais Brazil Business Directory Scraper (`crawlerbros/guiamais-scraper`) Actor

Scrape GuiaMais.com.br, Brazil's leading business directory. Search by category and city anywhere in Brazil, or fetch specific listings by URL. Get name, address, phone, category, rating, opening hours, photos and more - no login required.

- **URL**: https://apify.com/crawlerbros/guiamais-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 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/platform/actors/running/actors-in-store#pay-per-event

## 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## GuiaMais Brazil Business Directory Scraper

Scrape **GuiaMais.com.br** — Brazil's leading online business directory. Search any category and city across all 27 Brazilian states, or fetch specific business listing pages directly by URL. Get name, address, phone, category, rating, opening hours, photos, and more. HTTP-only, no login, no cookies, no API key required.

### What this actor does

- **Two modes:** `search` (category + city, nationwide) and `byUrl` (fetch specific listing pages directly)
- **Geographic scoping:** search any Brazilian city (60+ curated major cities plus free-text override for any of Brazil's thousands of municipalities) and filter by any of the 27 states/Distrito Federal (UF)
- **Rich business data:** name, category, full address (street/neighborhood/city/UF/CEP), phone numbers, WhatsApp number, rating, review count, opening hours, photos, logo
- **Optional deep enrichment:** turn on `fetchDetails` to additionally pull GPS coordinates, a Google Maps link, price range, and a full per-weekday opening-hours breakdown
- **Filters:** state (UF), city, minimum rating, "open now" only, "has photos" only, "verified businesses" only, "delivery available" only, free-text keyword filter
- **Empty fields are omitted** — every record only contains data actually found for that business
- **Full Portuguese/accent support** — city, neighborhood, and category names are preserved exactly (São Paulo, Brasília, Piauí, Ceará, Goiânia, etc.)

### Output per business

- `businessId`, `sourceUrl` — unique ID and canonical GuiaMais listing URL
- `name`
- `category`, `categoryUrl` — business category (e.g. `Pizzarias`, `Restaurantes`)
- `description`
- `street`, `neighborhood`, `city`, `state`, `postalCode`, `fullAddress`
- `latitude`, `longitude`, `mapUrl` — Google Maps link built from coordinates *(detail only)*
- `priceRange` *(detail only, when published)*
- `phone`, `phones[]` (all numbers on file), `whatsappNumber`, `whatsappChatUrl` — ready-to-send WhatsApp click-to-chat link
- `rating` (1-5), `reviewCount` — only present once the business has received reviews
- `profileCompleteness` — GuiaMais's own 0-100 listing-completeness score
- `openNow` (boolean), `openingHoursSummary` (short text), `openingSoon`/`closingSoon` (booleans), `openingHours[]` — per-weekday breakdown `{day, dayEn, hours}` *(detail only)*
- `logoUrl`, `photos[]`
- `verified` (boolean), `sponsored` (boolean), `plan` — GuiaMais listing tier (`free`, etc.)
- `directionsUrl` — GuiaMais-generated Google Maps directions link
- `recordType: "business"`, `scrapedAt`

*(detail only)* fields are only populated when `fetchDetails: true` is set (mode=search) or when using `mode: byUrl` (which always fetches the full listing page).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byUrl` |
| `category` | string (enum) | `Restaurante` | Curated category dropdown with a `customCategory` free-text override |
| `customCategory` | string | – | Free-text category, takes priority over `category` |
| `city` | string (enum) | `São Paulo, SP` | Curated dropdown of 60 major Brazilian cities with a `customCity` free-text override |
| `customCity` | string | – | Free-text city, format `City Name, UF`, takes priority over `city` |
| `state` | string (enum) | – | Restrict results to one of Brazil's 27 states/Distrito Federal (UF) |
| `urls` | array | – | GuiaMais business listing URLs (mode=byUrl) |
| `keyword` | string | – | Keep only results whose name/description/category contain this text |
| `minRating` | integer | – | Keep only results rated at or above this value (1-5) |
| `openNowOnly` | boolean | `false` | Only businesses currently marked open |
| `hasPhotosOnly` | boolean | `false` | Only businesses with at least one photo |
| `verifiedOnly` | boolean | `false` | Only businesses GuiaMais marks as verified |
| `deliveryOnly` | boolean | `false` | Only search businesses GuiaMais marks as offering delivery (mode=search; scopes the search itself) |
| `fetchDetails` | boolean | `false` | Visit each business's own listing page for GPS coordinates, map URL, price range, and full opening hours (1 extra request per business) |
| `maxItems` | integer | `30` | Hard cap (1-500) |
| `proxyConfiguration` | object | – | Optional; the site works without a proxy, the actor auto-escalates to the free AUTO group on repeated 403/429/503 |

#### Example: search with state + minimum rating

```json
{
  "mode": "search",
  "category": "Dentista",
  "city": "Rio de Janeiro, RJ",
  "state": "RJ",
  "minRating": 4,
  "maxItems": 50
}
````

#### Example: custom category and city, with full detail enrichment

```json
{
  "mode": "search",
  "customCategory": "Loja de Bicicletas",
  "customCity": "Piracicaba, SP",
  "fetchDetails": true,
  "maxItems": 100
}
```

#### Example: fetch specific listing pages

```json
{
  "mode": "byUrl",
  "urls": [
    "https://www.guiamais.com.br/sao-paulo-sp/restaurantes/pizzarias/11230918-3/jatoba-restaurante-pizzaria"
  ]
}
```

### Limitations

- **`deliveryOnly` scopes the GuiaMais search, it isn't a post-fetch record filter.** GuiaMais doesn't return a "delivery available" flag on individual business records — only its own search endpoint knows which businesses match, so this input narrows what GuiaMais itself searches rather than filtering records after the fact (like `openNowOnly`/`hasPhotosOnly`/`verifiedOnly` do).
- **`website` and `email` are not exposed.** GuiaMais's public search results and business detail pages do not surface a website link or email address for the businesses sampled during development — these fields simply are not part of the structured data GuiaMais publishes for public (non-logged-in) access, so they are not fabricated or forced into the output.
- **`rating`/`reviewCount` only appear once a business has received reviews.** GuiaMais shows a `0` placeholder for un-reviewed businesses; this actor omits the field entirely in that case rather than emitting a misleading zero.
- **Category list is curated, not exhaustive.** GuiaMais accepts any Portuguese business/service search term. The `category` field ships ~55 popular curated examples but accepts any free text via `customCategory` — it is not a locked taxonomy.
- **City list is curated, not exhaustive.** Brazil has thousands of municipalities. The `city` field ships 60 major cities (all state capitals plus other large metros) but accepts any Brazilian city via `customCity` (format `City Name, UF`).
- **Per-weekday opening hours and GPS coordinates require `fetchDetails`.** These fields only exist on each business's own listing page, not in the search-results list.
- **GPS coordinates (`latitude`/`longitude`/`mapUrl`) and `priceRange` are only present for a subset of businesses even with `fetchDetails` on.** GuiaMais only geocodes/publishes these for some listings; when a business's own page doesn't include them, the fields are simply omitted rather than fabricated.

### Use cases

- **Lead generation** — build prospect lists of local businesses by category, state, and city
- **Market research** — analyze business density and category coverage across Brazilian states and cities
- **Directory aggregation** — mirror or cross-reference Brazilian business listings
- **Local SEO audits** — check a business's own directory data (address, hours, phone, rating) for accuracy
- **Franchise/expansion planning** — map competitor or partner locations by category and geography
- **Sales prospecting** — export contact details (phone, WhatsApp) for a target category

### FAQ

**Do I need a GuiaMais account?** No. Search and listing pages are all publicly accessible without an account.

**Does the `city` filter guarantee I only get businesses in that city?** `city`/`customCity` are used both to scope the GuiaMais search directly (the site's own location-aware search) and as a best-effort text safety-net filter on the returned address.

**Does this actor return website or email addresses?** No — see Limitations above. GuiaMais does not publish these fields for public search results or listing pages.

**Why is `rating` sometimes missing?** Not every business has received reviews yet. The field is omitted rather than returned as `0`, which would misleadingly suggest a real (bad) rating.

**Why do `latitude`/`longitude`/`openingHours` only appear with `fetchDetails` on?** Those fields only exist on each business's own listing page, not in the search-results list. Turning on `fetchDetails` fetches that page for every result (one extra request per business, so it's slower but more complete).

**Can I search categories or cities not in the dropdowns?** Yes — use `customCategory` and/or `customCity` to type any Portuguese category or any Brazilian city (format `City Name, UF`).

**How fresh is the data?** GuiaMais listings are maintained by business owners and the platform's own data team; the actor always reads the live search results and pages at run time.

**Is this actor affiliated with GuiaMais?** No. This is an independent, third-party actor that reads GuiaMais's publicly available pages. It is not affiliated with, endorsed by, or sponsored by GuiaMais or its parent company.

# Actor input Schema

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

What to fetch.

## `category` (type: `string`):

Business category/type to search for. Pick one of the curated categories, or select "Custom category" and type any category in `customCategory` (any Portuguese business/service term works, even if not listed here, e.g. `Cirurgião Dentista`, `Loja de Bicicletas`).

## `customCategory` (type: `string`):

Free-text business category/type (Portuguese). Takes priority over `category` when set, e.g. `Cirurgião Dentista`, `Loja de Bicicletas`.

## `city` (type: `string`):

City to search within. Pick one of the 60 curated major Brazilian cities, or select "Custom city" and type any Brazilian city + state in `customCity` (format: `City Name, UF`).

## `customCity` (type: `string`):

Free-text Brazilian city, format `City Name, UF` (e.g. `Piracicaba, SP`, `Petrópolis, RJ`). Takes priority over `city` when set.

## `state` (type: `string`):

Only keep results located in this Brazilian state (UF). Leave empty for no state restriction. Also used to disambiguate `customCity` when it doesn't already include a UF.

## `urls` (type: `array`):

Full GuiaMais business listing URLs, e.g. `https://www.guiamais.com.br/sao-paulo-sp/restaurantes/pizzarias/11230918-3/jatoba-restaurante-pizzaria`.

## `keyword` (type: `string`):

Only keep results whose name, description, or category contains this text (case- and accent-insensitive).

## `minRating` (type: `integer`):

Only keep results with a rating greater than or equal to this value (1-5). Use 0 for no minimum. Records with no rating yet are excluded once this is set above 0.

## `openNowOnly` (type: `boolean`):

Only emit businesses currently marked as open on GuiaMais.

## `hasPhotosOnly` (type: `boolean`):

Only emit businesses that have at least one photo listed.

## `verifiedOnly` (type: `boolean`):

Only emit businesses GuiaMais marks as verified.

## `deliveryOnly` (type: `boolean`):

Only search businesses GuiaMais marks as offering delivery. This scopes the GuiaMais search itself (delivery availability isn't a field returned per business, so unlike the other filters it can't be applied after fetching).

## `fetchDetails` (type: `boolean`):

For mode=search: visit each business's own listing page to also collect geo-coordinates, map URL, price range, and full per-weekday opening hours. Slower (1 extra request per business). Always on for mode=byUrl.

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

Hard cap on emitted records.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. Leave empty to use no proxy — GuiaMais is publicly accessible without one. The actor automatically escalates to the free AUTO datacenter proxy group if it hits repeated 403/429/503 errors.

## Actor input object example

```json
{
  "mode": "search",
  "category": "Restaurante",
  "city": "São Paulo, SP",
  "state": "",
  "urls": [],
  "minRating": 0,
  "openNowOnly": false,
  "hasPhotosOnly": false,
  "verifiedOnly": false,
  "deliveryOnly": false,
  "fetchDetails": false,
  "maxItems": 30
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing all scraped GuiaMais businesses.

# 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": "search",
    "category": "Restaurante",
    "city": "São Paulo, SP",
    "state": "",
    "urls": [],
    "minRating": 0,
    "openNowOnly": false,
    "hasPhotosOnly": false,
    "verifiedOnly": false,
    "deliveryOnly": false,
    "fetchDetails": false,
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/guiamais-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": "search",
    "category": "Restaurante",
    "city": "São Paulo, SP",
    "state": "",
    "urls": [],
    "minRating": 0,
    "openNowOnly": False,
    "hasPhotosOnly": False,
    "verifiedOnly": False,
    "deliveryOnly": False,
    "fetchDetails": False,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/guiamais-scraper").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 '{
  "mode": "search",
  "category": "Restaurante",
  "city": "São Paulo, SP",
  "state": "",
  "urls": [],
  "minRating": 0,
  "openNowOnly": false,
  "hasPhotosOnly": false,
  "verifiedOnly": false,
  "deliveryOnly": false,
  "fetchDetails": false,
  "maxItems": 30
}' |
apify call crawlerbros/guiamais-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GuiaMais Brazil Business Directory Scraper",
        "description": "Scrape GuiaMais.com.br, Brazil's leading business directory. Search by category and city anywhere in Brazil, or fetch specific listings by URL. Get name, address, phone, category, rating, opening hours, photos and more - no login required.",
        "version": "1.0",
        "x-build-id": "rjbEe64jfwEfXephS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~guiamais-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-guiamais-scraper",
                "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/crawlerbros~guiamais-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-guiamais-scraper",
                "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/crawlerbros~guiamais-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-guiamais-scraper",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "category": {
                        "title": "Category (mode=search)",
                        "enum": [
                            "custom",
                            "Restaurante",
                            "Hotel",
                            "Farmácia",
                            "Advogado",
                            "Dentista",
                            "Veterinário",
                            "Academia",
                            "Padaria",
                            "Joalheria",
                            "Sapataria",
                            "Loja de Móveis",
                            "Lavanderia",
                            "Banco",
                            "Cartório",
                            "Contador",
                            "Arquiteto",
                            "Escola",
                            "Universidade",
                            "Óptica",
                            "Funerária",
                            "Posto de Gasolina",
                            "Cafeteria",
                            "Pizzaria",
                            "Salão de Beleza",
                            "Oficina Mecânica",
                            "Agência de Viagens",
                            "Locadora de Veículos",
                            "Empresa de Segurança",
                            "Mudanças",
                            "Encanador",
                            "Eletricista",
                            "Chaveiro",
                            "Pet Shop",
                            "Clínica Médica",
                            "Hospital",
                            "Laboratório",
                            "Imobiliária",
                            "Papelaria",
                            "Spa",
                            "Seguradora",
                            "Açougue",
                            "Loja de Eletrodomésticos",
                            "Supermercado",
                            "Floricultura",
                            "Bar",
                            "Lanchonete",
                            "Sorveteria",
                            "Confeitaria",
                            "Salão de Festas",
                            "Loja de Decoração",
                            "Construtora",
                            "Psicólogo",
                            "Fisioterapeuta",
                            "Nutricionista",
                            "Barbearia",
                            "Motel",
                            "Autoescola",
                            "Marcenaria"
                        ],
                        "type": "string",
                        "description": "Business category/type to search for. Pick one of the curated categories, or select \"Custom category\" and type any category in `customCategory` (any Portuguese business/service term works, even if not listed here, e.g. `Cirurgião Dentista`, `Loja de Bicicletas`).",
                        "default": "Restaurante"
                    },
                    "customCategory": {
                        "title": "Custom category override (mode=search)",
                        "type": "string",
                        "description": "Free-text business category/type (Portuguese). Takes priority over `category` when set, e.g. `Cirurgião Dentista`, `Loja de Bicicletas`."
                    },
                    "city": {
                        "title": "City (mode=search)",
                        "enum": [
                            "custom",
                            "São Paulo, SP",
                            "Rio de Janeiro, RJ",
                            "Brasília, DF",
                            "Salvador, BA",
                            "Fortaleza, CE",
                            "Belo Horizonte, MG",
                            "Manaus, AM",
                            "Curitiba, PR",
                            "Recife, PE",
                            "Porto Alegre, RS",
                            "Belém, PA",
                            "Goiânia, GO",
                            "Guarulhos, SP",
                            "Campinas, SP",
                            "São Luís, MA",
                            "São Gonçalo, RJ",
                            "Maceió, AL",
                            "Duque de Caxias, RJ",
                            "Natal, RN",
                            "Campo Grande, MS",
                            "Teresina, PI",
                            "São Bernardo do Campo, SP",
                            "Nova Iguaçu, RJ",
                            "João Pessoa, PB",
                            "Santo André, SP",
                            "Osasco, SP",
                            "Jaboatão dos Guararapes, PE",
                            "São José dos Campos, SP",
                            "Ribeirão Preto, SP",
                            "Uberlândia, MG",
                            "Sorocaba, SP",
                            "Contagem, MG",
                            "Aracaju, SE",
                            "Feira de Santana, BA",
                            "Cuiabá, MT",
                            "Joinville, SC",
                            "Juiz de Fora, MG",
                            "Londrina, PR",
                            "Aparecida de Goiânia, GO",
                            "Ananindeua, PA",
                            "Niterói, RJ",
                            "Porto Velho, RO",
                            "Serra, ES",
                            "Caxias do Sul, RS",
                            "Vila Velha, ES",
                            "Florianópolis, SC",
                            "Macapá, AP",
                            "Campos dos Goytacazes, RJ",
                            "São José do Rio Preto, SP",
                            "Mauá, SP",
                            "Diadema, SP",
                            "Vitória, ES",
                            "Boa Vista, RR",
                            "Palmas, TO",
                            "Rio Branco, AC",
                            "Gramado, RS",
                            "Foz do Iguaçu, PR",
                            "Ilhéus, BA",
                            "Piracicaba, SP",
                            "Bauru, SP",
                            "Santos, SP"
                        ],
                        "type": "string",
                        "description": "City to search within. Pick one of the 60 curated major Brazilian cities, or select \"Custom city\" and type any Brazilian city + state in `customCity` (format: `City Name, UF`).",
                        "default": "São Paulo, SP"
                    },
                    "customCity": {
                        "title": "Custom city override (mode=search)",
                        "type": "string",
                        "description": "Free-text Brazilian city, format `City Name, UF` (e.g. `Piracicaba, SP`, `Petrópolis, RJ`). Takes priority over `city` when set."
                    },
                    "state": {
                        "title": "State / UF filter (all modes)",
                        "enum": [
                            "",
                            "AC",
                            "AL",
                            "AP",
                            "AM",
                            "BA",
                            "CE",
                            "DF",
                            "ES",
                            "GO",
                            "MA",
                            "MT",
                            "MS",
                            "MG",
                            "PA",
                            "PB",
                            "PR",
                            "PE",
                            "PI",
                            "RJ",
                            "RN",
                            "RS",
                            "RO",
                            "RR",
                            "SC",
                            "SP",
                            "SE",
                            "TO"
                        ],
                        "type": "string",
                        "description": "Only keep results located in this Brazilian state (UF). Leave empty for no state restriction. Also used to disambiguate `customCity` when it doesn't already include a UF.",
                        "default": ""
                    },
                    "urls": {
                        "title": "Business listing URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Full GuiaMais business listing URLs, e.g. `https://www.guiamais.com.br/sao-paulo-sp/restaurantes/pizzarias/11230918-3/jatoba-restaurante-pizzaria`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Only keep results whose name, description, or category contains this text (case- and accent-insensitive)."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only keep results with a rating greater than or equal to this value (1-5). Use 0 for no minimum. Records with no rating yet are excluded once this is set above 0.",
                        "default": 0
                    },
                    "openNowOnly": {
                        "title": "Open now only",
                        "type": "boolean",
                        "description": "Only emit businesses currently marked as open on GuiaMais.",
                        "default": false
                    },
                    "hasPhotosOnly": {
                        "title": "Has photos only",
                        "type": "boolean",
                        "description": "Only emit businesses that have at least one photo listed.",
                        "default": false
                    },
                    "verifiedOnly": {
                        "title": "Verified businesses only",
                        "type": "boolean",
                        "description": "Only emit businesses GuiaMais marks as verified.",
                        "default": false
                    },
                    "deliveryOnly": {
                        "title": "Delivery available only (mode=search)",
                        "type": "boolean",
                        "description": "Only search businesses GuiaMais marks as offering delivery. This scopes the GuiaMais search itself (delivery availability isn't a field returned per business, so unlike the other filters it can't be applied after fetching).",
                        "default": false
                    },
                    "fetchDetails": {
                        "title": "Fetch full detail page per business",
                        "type": "boolean",
                        "description": "For mode=search: visit each business's own listing page to also collect geo-coordinates, map URL, price range, and full per-weekday opening hours. Slower (1 extra request per business). Always on for mode=byUrl.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Leave empty to use no proxy — GuiaMais is publicly accessible without one. The actor automatically escalates to the free AUTO datacenter proxy group if it hits repeated 403/429/503 errors."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
