# Mexico Company Data — DENUE Business Directory (5M+) (`foxlabs/mexico-denue-company-data`) Actor

Search ~5M Mexican businesses from INEGI's official DENUE directory by keyword, location or activity. Name, economic activity, size band, full address, geo-coordinates + phone/email/website. Official open data — commercial reuse permitted. No API key needed.

- **URL**: https://apify.com/foxlabs/mexico-denue-company-data.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation, Business
- **Stats:** 6 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.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

<p align="center"><a href="https://apify.com/foxlabs/mexico-denue-company-data"><img src="https://data.foxlabs.com.tr/img/mexico-denue-company-data-banner.svg" alt="Mexico Company Data Scraper — DENUE Directory (INEGI)" width="100%" /></a></p>

## Mexico Company Data — DENUE Business Directory (5M+)

Need **real, geo-located B2B data for the Mexican market** — not a scraped directory that breaks next week? This Actor turns **DENUE** — INEGI's official *Directorio Estadístico Nacional de Unidades Económicas* — into ready-to-use records: **~5 million business establishments** with name, economic activity, size band, full address, **exact geo-coordinates**, and self-reported **phone / email / website**.

Built on INEGI's **official REST API** — no scraping, no fragile HTML, **no API key to set up** (a working token is built in). Data is released under INEGI's *Términos de Libre Uso*, which **explicitly permit commercial reuse** (attribution: *Fuente: INEGI*).

- 🇲🇽 **~5M establishments** — DENUE's whole national directory, not a sample
- 📍 **Exact geo-coordinates on every record** — map, cluster or radius-search out of the box
- 📇 **Self-reported contact** — phone / email / website; **~62% have at least one** (measured)
- ⚡ **Official REST API, built-in token** — no scraping, no key setup, one clean flat dataset (JSON / CSV / Excel / API)

### Quick start (API)

Get 100 pharmacies in Jalisco that list contact info, in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~mexico-denue-company-data/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "keywords": ["farmacia"], "states": ["Jalisco"], "onlyWithContact": true, "maxResults": 100 }'
````

Prefer no code? Open the **Input** tab, set your filters, and click **Start** — then download the results.

### What you get

One clean, flat record per establishment:

| Field | Type | Description |
|---|---|---|
| `name` | string | Establishment / business name |
| `legalName` | string | Razón social (legal entity name), where reported |
| `id` / `clee` | string | INEGI establishment id + CLEE unique-establishment key |
| `activity` | string | Economic activity — SCIAN class (e.g. *Restaurantes con servicio de preparación de alimentos*) |
| `sizeBand` | string | Employee size stratum (e.g. *11 a 30 personas*) |
| `establishmentType` | string | Fixed / semi-fixed / mobile (*Fijo* / *Semifijo* / *Móvil*) |
| `street` / `exteriorNumber` / `interiorNumber` | string | Street address parts |
| `neighborhood` / `postalCode` | string | Colonia + CP (postal code) |
| `municipality` / `state` | string | Municipality + state |
| `fullAddress` | string | Ready-to-use single-line address |
| `latitude` / `longitude` | number | Exact geo-coordinates |
| `phone` / `email` / `website` | string | Self-reported contact (conservatively normalised; malformed values dropped) |
| `hasContact` / `contactMethods[]` | bool / array | Contact presence + which channels are populated |
| `source` / `sourceUrl` / `license` | string | Provenance: INEGI, the establishment's DENUE detail page, licence string |
| `scrapedAt` | string | ISO timestamp of the run |

Missing values come back as `null`, never a guess.

#### Sample output

```json
{
  "id": "6273041",
  "clee": "14039000456789012",
  "name": "Farmacia Guadalajara",
  "legalName": "Farmacias Guadalajara, S.A. de C.V.",
  "activity": "Comercio al por menor de productos farmacéuticos",
  "sizeBand": "11 a 30 personas",
  "establishmentType": "Fijo",
  "street": "Avenida Vallarta",
  "exteriorNumber": "1220",
  "interiorNumber": null,
  "neighborhood": "Americana",
  "postalCode": "44160",
  "municipality": "Guadalajara",
  "state": "Jalisco",
  "fullAddress": "Avenida Vallarta 1220, Americana, 44160, Guadalajara, Jalisco, México",
  "latitude": 20.6736,
  "longitude": -103.3688,
  "phone": "3336151234",
  "email": "contacto@ejemplo-farmacia.mx",
  "website": "https://www.ejemplo-farmacia.mx",
  "hasContact": true,
  "contactMethods": ["phone", "email", "website"],
  "source": "INEGI DENUE (Directorio Estadístico Nacional de Unidades Económicas)",
  "sourceUrl": "https://www.inegi.org.mx/app/mapa/denue/detalle.aspx?id=6273041",
  "license": "INEGI Términos de Libre Uso — Fuente: INEGI",
  "scrapedAt": "2026-07-05T09:12:44.101Z"
}
```

### Example inputs (copy & paste)

```jsonc
// 1) Lead list: pharmacies in Jalisco that list contact info
{ "keywords": ["farmacia"], "states": ["Jalisco"], "onlyWithContact": true, "maxResults": 1000 }

// 2) Everything around a point (≤ 5 km radius) — e.g. central Mexico City
{ "location": { "latitude": 19.4326, "longitude": -99.1332, "radiusMeters": 1000 }, "maxResults": 2000 }

// 3) A whole sector by SCIAN — restaurants (7225) across two states
{ "scianCode": "7225", "states": ["Nuevo León", "Jalisco"], "maxResults": 5000 }

// 4) Nationwide — hotels across all of Mexico (no states = whole country), contact only
{ "keywords": ["hotel"], "onlyWithContact": true, "maxResults": 3000 }

// 5) Multi-keyword lead list in one state — hardware & construction suppliers
{ "keywords": ["ferretería", "materiales para construcción"], "states": ["Ciudad de México"], "onlyWithContact": true, "maxResults": 1500 }

// 6) Browse a broad sector by 2-digit SCIAN — all retail (46) in a state by INEGI code (19 = Nuevo León)
{ "scianCode": "46", "states": ["19"], "maxResults": 10000 }

// 7) Field-sales radius around Guadalajara — reachable prospects only
{ "location": { "latitude": 20.6597, "longitude": -103.3496, "radiusMeters": 2000 }, "onlyWithContact": true, "maxResults": 1000 }
```

### Input & filters

There are **three ways to search** — pick one, or combine a keyword/activity with states:

- **Keywords** — one or more business terms (Spanish works best): `restaurante`, `farmacia`, `hotel`, `ferretería`. Combine with **States** to scope by region.
- **States** — a Mexican state name or 2-digit INEGI code (`Jalisco`, `Ciudad de México`, `19`). Leave empty to search the whole country.
- **Location radius** — `{ latitude, longitude, radiusMeters }` to pull every business around a point. Radius is capped at **5 km** by the source API.
- **Activity (SCIAN)** — a SCIAN code to browse an entire industry (`7225` = restaurants, `46` = retail), with or without a keyword; combine with States.
- **Only businesses with contact info** — keep only rows that reported at least one of phone / email / website (best for lead lists).
- **Max results** — 1–100,000.
- **INEGI API token** *(optional)* — a working token is built in; paste your own free token for heavy use.

### Use cases

- **B2B lead generation.** You sell POS, delivery or supplies to restaurants. Filter `keywords: ["restaurante"]` + a state + `onlyWithContact: true` → a CRM-ready list with phone/email/website and a **size band** to prioritise larger accounts — no manual list-building.
- **Local competitor mapping.** Opening or benchmarking a store? Run a `location` radius around the site → every competitor in the catchment, each with exact coordinates and size band, ready to plot on a map.
- **Territory & site selection.** Pull a whole `scianCode` sector across your target states → measure density and mix of businesses by municipality and colonia to choose where to open.
- **Field-sales route planning.** Query by keyword + state (or a location radius) and use the `latitude`/`longitude` on every record to cluster prospects by neighbourhood and build efficient visit routes.
- **Market sizing & research.** Browse an entire SCIAN sector nationally → count establishments by state, size band and establishment type to size a market and spot where the players concentrate.
- **Franchise & expansion scouting.** Filter a category + states, then map where it is already dense versus underserved to guide expansion decisions.

### Performance & throughput

Each search hits INEGI's **official REST API** directly — no proxies, no CAPTCHAs. A **location-radius** query is a single dense call, so it returns almost instantly. **Keyword + state** and **SCIAN** searches page through results in blocks of 1,000, so throughput scales with the size of your pull: a few thousand records complete in a minute or two, and large national pulls stream in steadily until they hit your `maxResults`. Throughput is bounded only by INEGI's API and your Apify plan; for sustained heavy volume, paste your own free INEGI token.

### Integrations

**JavaScript** (`apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('foxlabs/mexico-denue-company-data').call({
  keywords: ['farmacia'], states: ['Jalisco'], onlyWithContact: true, maxResults: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("foxlabs/mexico-denue-company-data").call(run_input={
    "keywords": ["farmacia"], "states": ["Jalisco"], "onlyWithContact": True, "maxResults": 500,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item.get("phone"))
```

Also works with **Make / n8n / Zapier** (Apify app → run this Actor, map the input), scheduled runs, webhooks, and the **Apify MCP server** for AI agents.

### Data quality (measured, not promised)

Live-measured on a **1,799-establishment sample** across Mexico City, Guadalajara, Monterrey and Cancún:

| Field group | Fill rate |
|---|---|
| Core (name, activity, size band, full address, geo) | **100%** |
| Any contact (phone / email / website) | **~62%** |
| Phone · Email · Website | ~38% · ~37% · ~17% |
| Legal name (razón social) | ~42% |

Contact coverage **rises with company size** — for firms of 11+ employees, **email reaches ~70–90%** and website ~50–85%. Turn on **Only businesses with contact info** for lead-ready lists. Contact fields come **only** from what each business self-reported to INEGI — never fabricated; missing values are `null`.

### Pricing

**Pay per result** — you're billed per establishment returned. **Only businesses with contact info** narrows the set to lead-ready records so you don't pay for rows you can't act on. There's an Apify **free tier** to evaluate the full feature set before you scale. No proxies or third-party costs — INEGI's API is free.

### FAQ

**Can I use this data commercially / resell it?** Yes — DENUE is published under INEGI's *Términos de Libre Uso*, which explicitly permit commercial reuse and redistribution *with attribution*. Every record carries the required `Fuente: INEGI` string.

**Do I need an INEGI API key or account?** No. A working token is built in, so the Actor runs out of the box. For heavy, sustained use you can paste your own free token — inegi.org.mx issues one instantly by email.

**How fresh is the data?** Each run reads live from INEGI's DENUE API, so you get the directory as INEGI currently publishes it. INEGI refreshes DENUE periodically.

**What export formats are available?** JSON, CSV, Excel, or via the Apify API and integrations.

**Does it include company directors, financials or ownership?** No. DENUE is a directory of *business establishments* (locations), not a corporate registry — it does not carry directors, financials or ownership. Those live in other registries.

**Why don't all records have a phone or email?** Contact is **self-reported** by each business; about ~62% reported at least one channel and the rest reported none. We normalise contacts and drop obviously-malformed values rather than ship junk — and never fabricate them.

**Can I pull a whole industry at once?** Yes — pass a **SCIAN code** (e.g. `7225` for restaurants, `46` for retail), optionally scoped to states, to browse an entire sector.

**Why is the location radius capped at 5 km?** That's a hard limit of INEGI's radius endpoint. For city- or country-scale lists, use keyword or SCIAN search combined with states instead.

**How many records can I get in one run?** Up to **100,000** via `maxResults`. A single dense city block can already return thousands.

**Is there a rate limit?** No key or per-request limit on our side — throughput is bounded by INEGI's API and your Apify plan. Supply your own INEGI token for sustained heavy volume.

### Troubleshooting

- **0 results** → your keyword may be too specific or a state name misspelled. Use Spanish terms, broaden the keyword, drop `onlyWithContact`, or switch to a **SCIAN code** to browse the whole sector.
- **Location search returns few rows** → the radius is capped at **5 km**. To cover a whole city, use keyword or SCIAN + state instead of a point radius.
- **A business has no email or phone** → about ~38% of establishments reported no contact at all; that's the source, not a miss (the value is `null`, never fabricated).
- **A large pull is slow or stalls** → keyword/SCIAN searches page in blocks of 1,000. Lower `maxResults`, scope to fewer states, or paste your own free INEGI token to sustain higher volume.

### Notes, limits & legal (honest)

- **Establishments, not legal entities.** DENUE is a directory of *business locations*; it does not include company directors, financials or ownership (those live in other registries). `legalName` (razón social) is present for ~42% of records.
- **Contact is self-reported.** ~62% of businesses list at least one contact method; the rest reported none. Phone/email/website are lightly normalised and obviously-malformed values are dropped rather than shipped — but occasional source typos exist. We never fabricate contact data.
- **Radius search is capped at 5 km** by the source API; use keyword-or-activity + state for country-scale lists.
- **Attribution required.** Each record carries `Fuente: INEGI`; keep the attribution when you redistribute (a condition of the open licence).
- **Personal data.** Some contacts (e.g. sole-trader phone/email) are personal data — use them lawfully, for legitimate B2B, research and marketing in line with applicable law.
- **Not affiliated** with INEGI or the Mexican government; this Actor redistributes their public open data.

### Support

Questions, a field you'd like added, or a custom build? Open the **Issues** tab on this Actor, or email **info@foxlabs.com.tr**. We reply fast.

*If this Actor saves you time, a ⭐ review really helps.*

### Changelog

#### 0.2 — 2026-07-05

- Reworked docs: API quick-start, sample output, integrations, FAQ & troubleshooting.

#### 0.1

- Initial release. Keyword+state, location-radius and SCIAN-activity search over DENUE's ~5M establishments; clean firmographics + address + geo + normalised contact; `onlyWithContact` filter; official INEGI REST API, built-in token.

***

Part of the **[foXLabs data platform](https://data.foxlabs.com.tr/)** — official public-data company, contact, ownership, jobs, charity, location & AI-search intelligence scrapers. Browse the full suite at **[data.foxlabs.com.tr](https://data.foxlabs.com.tr/)**.

# Actor input Schema

## `keywords` (type: `array`):

Business keywords or activities to search — e.g. "restaurante", "farmacia", "hotel", "ferretería". Combine with States to scope by region.

## `states` (type: `array`):

Mexican states to search — name or 2-digit INEGI code (e.g. "Jalisco", "Ciudad de México", "19"). Leave empty to search the whole country.

## `location` (type: `object`):

Alternative to keyword search: find every business within a radius of a point. { "latitude": 19.4326, "longitude": -99.1332, "radiusMeters": 1000 }. Max radius 5000 m.

## `scianCode` (type: `string`):

Browse an entire industry by SCIAN code, e.g. "7225" (restaurants) or "46" (retail). Works without a keyword — combine with States. Full list: INEGI SCIAN.

## `onlyWithContact` (type: `boolean`):

Return only establishments that reported at least one of phone / email / website. Best for lead-generation lists (~62% of businesses have contact info).

## `maxResults` (type: `integer`):

Maximum number of establishments to return (1–100000). A single dense city block can already return thousands.

## `apiToken` (type: `string`):

Optional. A working token is built in, so you can run this out of the box. For heavy use you may supply your own free token from inegi.org.mx (email-only signup, 30 seconds).

## Actor input object example

```json
{
  "keywords": [
    "restaurante"
  ],
  "states": [
    "Ciudad de México"
  ],
  "onlyWithContact": false,
  "maxResults": 500
}
```

# Actor output Schema

## `dataset` (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 = {
    "keywords": [
        "restaurante"
    ],
    "states": [
        "Ciudad de México"
    ],
    "maxResults": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/mexico-denue-company-data").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 = {
    "keywords": ["restaurante"],
    "states": ["Ciudad de México"],
    "maxResults": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/mexico-denue-company-data").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 '{
  "keywords": [
    "restaurante"
  ],
  "states": [
    "Ciudad de México"
  ],
  "maxResults": 500
}' |
apify call foxlabs/mexico-denue-company-data --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mexico Company Data — DENUE Business Directory (5M+)",
        "description": "Search ~5M Mexican businesses from INEGI's official DENUE directory by keyword, location or activity. Name, economic activity, size band, full address, geo-coordinates + phone/email/website. Official open data — commercial reuse permitted. No API key needed.",
        "version": "0.1",
        "x-build-id": "nArCwVUTZr0VuLu2g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/foxlabs~mexico-denue-company-data/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-foxlabs-mexico-denue-company-data",
                "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/foxlabs~mexico-denue-company-data/runs": {
            "post": {
                "operationId": "runs-sync-foxlabs-mexico-denue-company-data",
                "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/foxlabs~mexico-denue-company-data/run-sync": {
            "post": {
                "operationId": "run-sync-foxlabs-mexico-denue-company-data",
                "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",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Business keywords or activities to search — e.g. \"restaurante\", \"farmacia\", \"hotel\", \"ferretería\". Combine with States to scope by region.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Mexican states to search — name or 2-digit INEGI code (e.g. \"Jalisco\", \"Ciudad de México\", \"19\"). Leave empty to search the whole country.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location radius",
                        "type": "object",
                        "description": "Alternative to keyword search: find every business within a radius of a point. { \"latitude\": 19.4326, \"longitude\": -99.1332, \"radiusMeters\": 1000 }. Max radius 5000 m."
                    },
                    "scianCode": {
                        "title": "Activity code (SCIAN)",
                        "type": "string",
                        "description": "Browse an entire industry by SCIAN code, e.g. \"7225\" (restaurants) or \"46\" (retail). Works without a keyword — combine with States. Full list: INEGI SCIAN."
                    },
                    "onlyWithContact": {
                        "title": "Only businesses with contact info",
                        "type": "boolean",
                        "description": "Return only establishments that reported at least one of phone / email / website. Best for lead-generation lists (~62% of businesses have contact info).",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of establishments to return (1–100000). A single dense city block can already return thousands.",
                        "default": 500
                    },
                    "apiToken": {
                        "title": "INEGI API token (optional)",
                        "type": "string",
                        "description": "Optional. A working token is built in, so you can run this out of the box. For heavy use you may supply your own free token from inegi.org.mx (email-only signup, 30 seconds)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
