# OpenStreetMap Nominatim Geocoder (`parseforge/nominatim-osm-scraper`) Actor

Geocode addresses and search POIs worldwide using OpenStreetMap Nominatim. Returns coordinates, full address components (city, country, state, postcode), OSM tags, bounding box, importance score. Works for addresses, businesses, landmarks.

- **URL**: https://apify.com/parseforge/nominatim-osm-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.99 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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.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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🌍 Nominatim OpenStreetMap Geocoder

> 🕒 **Last updated:** 2026-05-05


Turn addresses, landmarks, and place names into structured coordinates anywhere on Earth. This tool runs batch geocoding against OpenStreetMap's global Nominatim service, returning latitude, longitude, and full address components so you can enrich CRM records, power maps, or clean up customer data in bulk.

> **The Nominatim OSM Scraper converts free-form text queries into structured place records with coordinates, full address components, bounding boxes, OSM IDs, and type classification worldwide.**

### ✨ What Does It Do

- 📍 **Worldwide coverage** - geocode addresses and places in every country
- 🗺️ **Full address breakdown** - street, city, county, state, country, postal code split into fields
- 📐 **Coordinates + bounding box** - precise latitude/longitude plus bounding rectangle
- 🏷️ **Place classification** - type (city, village, landmark) and category (amenity, tourism, etc.)
- 🌍 **Country filtering** - limit searches to specific countries with ISO codes
- 🆔 **OSM identifiers** - OSM type, ID, and place ID for cross-referencing
- 📑 **Extra tags and name details** - alternate names and extended attributes

### 🔧 Input

- **Search Queries** - list of free-form text queries (e.g. `Eiffel Tower`, `10 Downing Street London`, `Times Square NYC`)
- **Max Results Per Query** - how many matches to return per query, 1-50
- **Country Codes** - optional ISO 3166-1 alpha-2 codes comma-separated (e.g. `us,ca,mx`)
- **Max Items** - free users get 10 records, paid users up to 1,000,000

```json
{
    "queries": ["Eiffel Tower", "Times Square NYC", "Colosseum Rome"],
    "maxPerQuery": 3,
    "maxItems": 50
}
````

### 📊 Output

Each record is a matched place with full address and coordinates. Download as JSON, CSV, or Excel.

| 📌 Field | 📄 Description |
|----------|---------------|
| 🔍 query | Original search query |
| 📋 displayName | Full human-readable place name |
| 📝 name | Primary place name |
| 🏷️ type | Place type (city, landmark, etc.) |
| 📂 category | OSM category (tourism, amenity, etc.) |
| 📍 latitude | Latitude in WGS84 |
| 📍 longitude | Longitude in WGS84 |
| 🛣️ street | Road/street name |
| 🏙️ city | City, town, or village |
| 🗺️ state | State or region |
| 🌍 country | Country full name |
| 🏷️ countryCode | 2-letter country code |
| 📮 postcode | Postal code |
| 📐 boundingBox | Bounding box coordinates |
| 🆔 osmType | OSM object type |
| 🆔 osmId | OSM object ID |

```json
{
    "query": "Eiffel Tower",
    "displayName": "Tour Eiffel, 5, Avenue Anatole France, Gros-Caillou, 7th Arrondissement, Paris, Île-de-France, Metropolitan France, 75007, France",
    "name": "Tour Eiffel",
    "type": "attraction",
    "category": "tourism",
    "latitude": 48.8582602,
    "longitude": 2.2944991,
    "street": "Avenue Anatole France",
    "city": "Paris",
    "state": "Île-de-France",
    "country": "France",
    "countryCode": "FR",
    "postcode": "75007",
    "importance": 0.9571,
    "osmType": "way",
    "osmId": "5013364",
    "boundingBox": "48.857891,48.858623,2.293925,2.295074",
    "scrapedAt": "2026-04-10T12:00:00.000Z"
}
```

### 💎 Why Choose the Nominatim OSM Scraper?

| Feature | Our Tool | Manual Geocoding |
|---------|----------|------------------|
| Batch geocoding | ✅ Bulk queries | ❌ One at a time |
| Global coverage | ✅ Every country | ⚠️ Varies by provider |
| Full address split | ✅ Structured fields | ⚠️ Single text |
| Country filter | ✅ ISO codes | ⚠️ Limited |
| Bounding box included | ✅ Yes | ⚠️ Rare |
| Export to JSON/CSV/Excel | ✅ Yes | ❌ Not supported |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - paste your search queries and optional country filter
3. **Run It** - click Start and get structured place records in seconds

No coding, no per-request lookups, no paid geocoding bills.

### 🎯 Business Use Cases

- 🗺️ **CRM enrichment** - geocode customer addresses to enable map views and routing
- 🚚 **Logistics** - resolve delivery addresses to coordinates for route optimization
- 📱 **Map applications** - power location search in your mobile or web app
- 📊 **Data cleaning** - verify and standardize address data in CSV imports
- 🏪 **Store locators** - geocode branch addresses for distance-based lookups
- 🌍 **Travel apps** - convert points of interest into coordinates for itineraries

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🎯 | **Built for the job.** Scoped specifically to this data source so you skip the parser engineering entirely. |
| 🔖 | **Structured output.** Clean, typed fields ready for analysis, dashboards, or downstream pipelines. |
| ⚡ | **Fast.** Optimized request patterns return results in seconds, not minutes. |
| 🔁 | **Always fresh.** Every run pulls live data, so the dataset reflects the source as of run time. |
| 🌐 | **No infra to manage.** Apify handles proxies, retries, scaling, scheduling, and storage. |
| 🛡️ | **Reliable.** Battle-tested across many runs and edge cases, with graceful error handling. |
| 🚫 | **No code required.** Configure in the UI, run from CLI, schedule via cron, or call from any language with the Apify SDK. |

> 📊 Production-grade structured data without the engineering overhead of building and maintaining your own scraper.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Nominatim OpenStreetMap Geocoder** *(this Actor)* | $5 free credit, then pay-per-use | Full source coverage | **Live per run** | Source-native filters supported | ⚡ 2 min |
| Build your own scraper | Engineering hours | Full once built | Whenever you maintain it | Custom code | 🐢 Days to weeks |
| Paid managed APIs | $$$ monthly | Vendor-defined | Live | Vendor-defined | ⏳ Hours |
| Third-party data dumps | Varies | Subset, often stale | Periodic | None | 🕒 Variable |

Pick this Actor when you want broad coverage, server-side filtering, and no pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Nominatim OpenStreetMap Geocoder page on the Apify Store.
3. 🎯 **Set input.** Configure the input fields in the form (or paste a JSON), then set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📊 Data & Analytics

- Build trend reports and dashboards from live source data
- Feed BI tools, warehouses, and ML pipelines with structured records
- Run periodic snapshots to track changes over time
- Compare segments, regions, or categories with consistent fields

</td>
<td width="50%" valign="top">

#### 🏢 Operations & Strategy

- Monitor competitor moves, pricing, and inventory shifts
- Build internal directories and lookup tools backed by current data
- Power workflows that depend on fresh source records
- Cut manual data-gathering time from hours to minutes

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🎯 Marketing & Growth

- Identify market opportunities and trending topics
- Research target audiences and customer personas at scale
- Power lead-generation pipelines with verified records
- Track sentiment, reviews, or social signals over time

</td>
<td width="50%" valign="top">

#### 🛠️ Engineering & Product

- Prototype features that need real-world data without owning a crawler
- Replace fragile in-house scrapers with a managed Actor
- Wire datasets into your apps via the Apify API or webhooks
- Skip the proxy, retry, and parsing maintenance entirely

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Geocoded datasets for spatial analysis and GIS coursework
- Reproducible research with cited, versioned dataset pulls
- OpenStreetMap data quality studies and contributor analytics
- Classroom exercises on geocoding, mapping, and ethics

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, indie travel apps, and portfolio demos
- Custom map visualizations, dashboards, and infographics
- Content research for travel bloggers and creators
- Hobbyist databases of points of interest

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Disaster-response logistics with geocoded address mapping
- Civic transparency around regional infrastructure
- Investigative journalism on location-based patterns
- OpenStreetMap community contributions and validation

</td>
<td width="50%">

#### 🧪 Experimentation

- Train geocoding-quality or address-classification models
- Validate location-based product hypotheses with real data
- Prototype agent pipelines that resolve addresses to coordinates
- Test dashboard concepts with live location feeds

</td>
</tr>
</table>

### 🔌 Integrate with any app

Nominatim OpenStreetMap Geocoder connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe results into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh data into your product backend, or alert your team in Slack.

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Nominatim%20OSM%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Nominatim%20OSM%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Nominatim%20OSM%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Nominatim%20OSM%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

### ❓ Frequently Asked Questions

🌍 **What is Nominatim?**
Nominatim is the official geocoding service built on OpenStreetMap, the open map of the world maintained by a global community of contributors.

📍 **What kind of queries work?**
Any free-form text: street addresses, landmark names, city names, postal codes, or combinations. Examples: `Eiffel Tower Paris`, `10 Downing Street London`, `1600 Pennsylvania Ave`, `M5V 3L9`.

🏷️ **How accurate are the coordinates?**
Accuracy depends on the OpenStreetMap data for the area. Major landmarks and urban addresses are usually spot-on; rural areas can vary.

🌐 **Can I limit searches to specific countries?**
Yes. Pass ISO 3166-1 alpha-2 codes (comma-separated) like `us,ca,mx` in the Country Codes field.

⏱️ **How many queries can I run?**
Up to 1 million queries for paid users. The tool automatically paces requests to respect Nominatim's usage policy.

🌍 **What languages do the results come in?**
You can request results in any language. Pass a `languages` value like `en`, `es`, `fr`, `de`, `ja`, or any IETF tag. Field values like `display_name` and `name` come back in the requested language when OpenStreetMap has it.

🏠 **Does it return full address breakdowns?**
Yes. Each record includes a structured `address` object with house number, street, city, postcode, country, country code, neighbourhood, and administrative levels (state, county, region) when available.

📐 **Can I do reverse geocoding too?**
Yes. Switch the mode to `reverse` and pass latitude/longitude pairs. The Actor returns the closest matching address with the same field structure as forward search.

🗺️ **What types of places are supported?**
Anything OpenStreetMap maps: addresses, points of interest, businesses, parks, mountains, rivers, administrative regions, postal codes, and more. The `class` and `type` fields tell you the kind of place each result is.

🔢 **Why do some queries return multiple results?**
For ambiguous queries (e.g. `Springfield`, `Main Street`) Nominatim returns ranked candidates. The Actor surfaces all of them so you can pick the best by `importance` score or by filtering on country.

📊 **Can I get bounding boxes for each result?**
Yes. Every record includes a `boundingBox` array (south, north, west, east) defining the geographic extent of the place, useful for map zoom or area queries.

🆔 **What is `placeId` and `osmId`?**
`placeId` is Nominatim's internal stable identifier for that specific match. `osmId` is the underlying OpenStreetMap node, way, or relation ID - useful if you want to look up the raw OSM record.

🔄 **Does the data refresh in real time?**
The Actor hits Nominatim live, so results reflect the current OpenStreetMap state at run time. OSM contributors update the underlying data continuously.

### 🔗 Integrate Nominatim OSM Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - automate address geocoding
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - enrich new CRM records
- [Slack](https://docs.apify.com/platform/integrations/slack) - post geocoding summaries
- [Google Sheets](https://docs.apify.com/platform/integrations/drive) - add coordinates to address sheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - trigger workflows on completion

### 💡 Recommended Actors

Looking for more data collection tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| GreatSchools Scraper | School ratings and district data | [Link](https://apify.com/parseforge/greatschools-scraper) |
| REMAX Real Estate Scraper | Property listings from REMAX | [Link](https://apify.com/parseforge/remax-scraper) |
| LoopNet Business Listings Scraper | Commercial real estate data | [Link](https://apify.com/parseforge/loopnet-scraper) |
| Auction.com Property Scraper | Real estate auction listings | [Link](https://apify.com/parseforge/auction-com-property-scraper) |
| James Edition Real Estate Scraper | Luxury property listings | [Link](https://apify.com/parseforge/james-edition-real-estate-scraper) |

**Pro Tip:** 💡 Browse the full [ParseForge catalog](https://apify.com/parseforge) to find more data tools.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to OpenStreetMap, Nominatim, or the OpenStreetMap Foundation. It uses only publicly available geocoding services.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Search: geocode addresses or place names (text -> coordinates). Reverse: reverse-geocode coordinates (lat,lng -> full address). Lookup: fetch a place by OSM type+id.

## `queries` (type: `array`):

Search mode only. One free-form query per line (addresses, POI names, landmarks). Nominatim is a geocoder, so each query usually returns 1-5 matches; run many queries at once to build a larger dataset.

## `coordinates` (type: `array`):

Reverse mode only. One `latitude,longitude` pair per line (e.g. `48.8584,2.2945`).

## `osmIds` (type: `array`):

Lookup mode only. One `<type><id>` per line where type is N (node), W (way), or R (relation). Example: `R146656` for France.

## `limitPerQuery` (type: `integer`):

Search mode only. Maximum rows Nominatim returns per query (hard cap is 40 on the public server).

## `countryCodes` (type: `string`):

Search mode only. Comma-separated ISO 3166-1 alpha-2 codes to restrict results (e.g. `us,ca,mx`).

## `language` (type: `string`):

Preferred language for display name and address components (e.g. `en`, `es`, `fr`, `de`, `ja`).

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "search",
  "queries": [
    "Eiffel Tower",
    "Times Square NYC",
    "Colosseum Rome",
    "Tokyo Tower",
    "Sydney Opera House",
    "10 Downing Street London",
    "Brandenburg Gate Berlin",
    "Statue of Liberty",
    "Taj Mahal",
    "Christ the Redeemer Rio"
  ],
  "coordinates": [
    "48.8584,2.2945",
    "40.7580,-73.9855",
    "41.8902,12.4922"
  ],
  "osmIds": [
    "R146656",
    "R62422",
    "R1221769"
  ],
  "limitPerQuery": 10,
  "language": "en"
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "mode": "search",
    "queries": [
        "Eiffel Tower",
        "Times Square NYC",
        "Colosseum Rome",
        "Tokyo Tower",
        "Sydney Opera House",
        "10 Downing Street London",
        "Brandenburg Gate Berlin",
        "Statue of Liberty",
        "Taj Mahal",
        "Christ the Redeemer Rio"
    ],
    "coordinates": [
        "48.8584,2.2945",
        "40.7580,-73.9855",
        "41.8902,12.4922"
    ],
    "osmIds": [
        "R146656",
        "R62422",
        "R1221769"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nominatim-osm-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 = {
    "maxItems": 10,
    "mode": "search",
    "queries": [
        "Eiffel Tower",
        "Times Square NYC",
        "Colosseum Rome",
        "Tokyo Tower",
        "Sydney Opera House",
        "10 Downing Street London",
        "Brandenburg Gate Berlin",
        "Statue of Liberty",
        "Taj Mahal",
        "Christ the Redeemer Rio",
    ],
    "coordinates": [
        "48.8584,2.2945",
        "40.7580,-73.9855",
        "41.8902,12.4922",
    ],
    "osmIds": [
        "R146656",
        "R62422",
        "R1221769",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nominatim-osm-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 '{
  "maxItems": 10,
  "mode": "search",
  "queries": [
    "Eiffel Tower",
    "Times Square NYC",
    "Colosseum Rome",
    "Tokyo Tower",
    "Sydney Opera House",
    "10 Downing Street London",
    "Brandenburg Gate Berlin",
    "Statue of Liberty",
    "Taj Mahal",
    "Christ the Redeemer Rio"
  ],
  "coordinates": [
    "48.8584,2.2945",
    "40.7580,-73.9855",
    "41.8902,12.4922"
  ],
  "osmIds": [
    "R146656",
    "R62422",
    "R1221769"
  ]
}' |
apify call parseforge/nominatim-osm-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenStreetMap Nominatim Geocoder",
        "description": "Geocode addresses and search POIs worldwide using OpenStreetMap Nominatim. Returns coordinates, full address components (city, country, state, postcode), OSM tags, bounding box, importance score. Works for addresses, businesses, landmarks.",
        "version": "1.0",
        "x-build-id": "lQLi9i6oPje5DEfDK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nominatim-osm-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nominatim-osm-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/parseforge~nominatim-osm-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nominatim-osm-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/parseforge~nominatim-osm-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nominatim-osm-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",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "reverse",
                            "lookup"
                        ],
                        "type": "string",
                        "description": "Search: geocode addresses or place names (text -> coordinates). Reverse: reverse-geocode coordinates (lat,lng -> full address). Lookup: fetch a place by OSM type+id."
                    },
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Search mode only. One free-form query per line (addresses, POI names, landmarks). Nominatim is a geocoder, so each query usually returns 1-5 matches; run many queries at once to build a larger dataset.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "coordinates": {
                        "title": "Coordinates",
                        "type": "array",
                        "description": "Reverse mode only. One `latitude,longitude` pair per line (e.g. `48.8584,2.2945`).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "osmIds": {
                        "title": "OSM IDs",
                        "type": "array",
                        "description": "Lookup mode only. One `<type><id>` per line where type is N (node), W (way), or R (relation). Example: `R146656` for France.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "limitPerQuery": {
                        "title": "Results Per Query",
                        "minimum": 1,
                        "maximum": 40,
                        "type": "integer",
                        "description": "Search mode only. Maximum rows Nominatim returns per query (hard cap is 40 on the public server).",
                        "default": 10
                    },
                    "countryCodes": {
                        "title": "Country Codes",
                        "type": "string",
                        "description": "Search mode only. Comma-separated ISO 3166-1 alpha-2 codes to restrict results (e.g. `us,ca,mx`)."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Preferred language for display name and address components (e.g. `en`, `es`, `fr`, `de`, `ja`).",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
