# US Address Checker & GPS Finder: Verify & Geocode (`scrapemint/us-address-checker`) Actor

Check US addresses in bulk: is it a real address, the cleaned up official version, and its exact GPS location for maps. Plus county, city and district info. Paste one address or thousands. Bulk address checker and geocoder built on official US Census data. No API key needed.

- **URL**: https://apify.com/scrapemint/us-address-checker.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## US Address Checker & GPS Finder: Verify & Geocode

Check US addresses in bulk. Paste one address or thousands and get one clean row per address: is it real, the cleaned up official version, and its exact GPS location for maps. Plus the county, official city, congressional district and census tract when you want them.

Built for **real estate and logistics teams, mailing list owners, market researchers and app builders**. Built on the official US Census Bureau geocoder, so there is no API key, no signup and no per-seat license.

### What you get for each address

- **Found or not**: instantly flags addresses that do not exist.
- **The cleaned official version**: "1600 pennsylvania ave washington dc" becomes "1600 PENNSYLVANIA AVE NW, WASHINGTON, DC, 20500".
- **GPS location** (latitude, longitude) ready for maps and routing.
- **Area info** (on by default): county with FIPS code, official city or town, congressional district and census tract, the fields analysts join demographics on.

### Example output

```json
{
  "input": "1600 Pennsylvania Ave NW, Washington, DC",
  "matched": true,
  "cleanAddress": "1600 PENNSYLVANIA AVE NW, WASHINGTON, DC, 20500",
  "latitude": 38.89869893252,
  "longitude": -77.03518753691,
  "city": "WASHINGTON",
  "state": "DC",
  "zip": "20500",
  "county": "District of Columbia",
  "countyFips": "11001",
  "officialPlace": "Washington city",
  "congressionalDistrict": "Delegate District (at Large)",
  "censusTract": "11001980000"
}
````

### Pricing

**$0.001 per address found**, and addresses that cannot be found are **free**, so cleaning a dirty list never costs you for the bad rows. The first 2 rows of every run are free.

| List size | Typical geocoding service | This actor |
| --- | --- | --- |
| 1,000 addresses | $0.50 to $5, signup and API key required | **$1, no signup** |
| 10,000 addresses | $5 to $50 plus monthly minimums | **$10 or less** |

### How to run it via API

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapemint~us-address-checker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"addresses": ["350 5th Ave, New York, NY 10118", "1 Apple Park Way, Cupertino, CA"]}'
```

### Frequently asked questions

**Does it work outside the US?** No, US addresses only (including DC and Puerto Rico). That is what the Census geocoder covers.

**How accurate is it?** It matches against the Census Bureau's national address database, the same data behind official statistics. Addresses it cannot match are flagged rather than guessed.

**What is a census tract and why would I care?** It is the small area code that all US demographic data is published against. With it you can join income, population and housing stats onto your address list.

### More tools from Scrapemint

- [Home Prices & Listings Scraper](https://apify.com/scrapemint/home-listings-scraper): US homes for sale by area.
- [Email List Checker](https://apify.com/scrapemint/email-list-checker): clean email lists in bulk.
- [Healthcare Provider Leads](https://apify.com/scrapemint/healthcare-provider-leads): US healthcare provider contacts by specialty and state.

# Actor input Schema

## `addresses` (type: `array`):

One full address per line, e.g. 1600 Pennsylvania Ave NW, Washington, DC. You can paste thousands, they are checked in bulk.

## `includeAreaInfo` (type: `boolean`):

Also return the county, official city or town, congressional district and census tract for each address.

## `maxRows` (type: `integer`):

Cap on addresses checked. Controls total cost. First 2 rows per run are free; addresses that cannot be found are always free.

## Actor input object example

```json
{
  "addresses": [
    "1600 Pennsylvania Ave NW, Washington, DC",
    "11 Wall St, New York, NY",
    "350 5th Ave, New York, NY 10118",
    "233 S Wacker Dr, Chicago, IL 60606",
    "1600 Amphitheatre Pkwy, Mountain View, CA"
  ],
  "includeAreaInfo": true,
  "maxRows": 500
}
```

# 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 = {
    "addresses": [
        "1600 Pennsylvania Ave NW, Washington, DC",
        "11 Wall St, New York, NY",
        "350 5th Ave, New York, NY 10118",
        "233 S Wacker Dr, Chicago, IL 60606",
        "1600 Amphitheatre Pkwy, Mountain View, CA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/us-address-checker").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 = { "addresses": [
        "1600 Pennsylvania Ave NW, Washington, DC",
        "11 Wall St, New York, NY",
        "350 5th Ave, New York, NY 10118",
        "233 S Wacker Dr, Chicago, IL 60606",
        "1600 Amphitheatre Pkwy, Mountain View, CA",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/us-address-checker").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 '{
  "addresses": [
    "1600 Pennsylvania Ave NW, Washington, DC",
    "11 Wall St, New York, NY",
    "350 5th Ave, New York, NY 10118",
    "233 S Wacker Dr, Chicago, IL 60606",
    "1600 Amphitheatre Pkwy, Mountain View, CA"
  ]
}' |
apify call scrapemint/us-address-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Address Checker & GPS Finder: Verify & Geocode",
        "description": "Check US addresses in bulk: is it a real address, the cleaned up official version, and its exact GPS location for maps. Plus county, city and district info. Paste one address or thousands. Bulk address checker and geocoder built on official US Census data. No API key needed.",
        "version": "0.1",
        "x-build-id": "7mdM6Ui2RXLbSFaF6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~us-address-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-us-address-checker",
                "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/scrapemint~us-address-checker/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-us-address-checker",
                "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/scrapemint~us-address-checker/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-us-address-checker",
                "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": {
                    "addresses": {
                        "title": "US addresses",
                        "type": "array",
                        "description": "One full address per line, e.g. 1600 Pennsylvania Ave NW, Washington, DC. You can paste thousands, they are checked in bulk.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeAreaInfo": {
                        "title": "Include area info",
                        "type": "boolean",
                        "description": "Also return the county, official city or town, congressional district and census tract for each address.",
                        "default": true
                    },
                    "maxRows": {
                        "title": "Max rows per run",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Cap on addresses checked. Controls total cost. First 2 rows per run are free; addresses that cannot be found are always free.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
