# Denmark Address Validator & Geocoder (`nexgendata/denmark-address-validator`) Actor

Validate, normalize & geocode any Danish address using DAWA — Denmarks official open registry of 2.5M+ addresses. Forward, reverse & postcode lookup with municipality & region codes. No API key needed.

- **URL**: https://apify.com/nexgendata/denmark-address-validator.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## 🇩🇰 Denmark Address Validator & Geocoder

**Validate, normalize, and geocode any Danish address using DAWA — the official open-data registry of all 2.5M+ addresses in Denmark.**

This actor wraps Denmark's free [DAWA (Danmarks Adresser Web API)](https://dawa.aws.dk/) — the authoritative source maintained by Styrelsen for Dataforsyning og Effektivisering. It returns clean, schema-mapped address records with GPS coordinates, postal codes, municipality codes, and region info — perfect for CRM cleanup, logistics routing, and Danish e-commerce.

### What it does

Three modes, one actor:

- **Forward geocoding** — fuzzy-match a free-text Danish address (with typos, partial input, or just a street name) and get back validated, normalized records with coordinates.
- **Reverse geocoding** — supply a `latitude` + `longitude` and get the closest official Danish address.
- **Postcode listing** — supply a 4-digit Danish postcode (e.g. `1050`) and list addresses inside it, useful for delivery zone enrichment.

### Why use this instead of Google Maps Geocoding?

| | This actor | Google Maps Geocoding | Loqate / Twilio Lookup |
|---|---|---|---|
| Denmark coverage | 2.5M addresses (official) | partial, normalized for international use | partial |
| Cost (1,000 addresses) | $10 | ~$5 + Google API fees + key management | $30+ |
| Source authority | Danish government (DAWA) | derived | derived |
| Includes municipality / region codes | yes | no | no |
| API key management | none | required | required |
| Data freshness | every minute | varies | weekly |

For Denmark specifically, DAWA is the source of truth that everyone else derives from. This actor lets you tap it directly, normalize the output to English-friendly field names, and bulk-process address lists without writing your own client.

### Example output

```json
{
  "id": "0b6a0c6f-ed2b-4cc7-9b29-956bdfe670fd",
  "address": "Nørrebrogade 10, 2200 København N",
  "street": "Nørrebrogade",
  "house_number": "10",
  "floor": null,
  "door": null,
  "postcode": "2200",
  "city": "København N",
  "municipality_code": "0101",
  "municipality": "København",
  "region_code": "1084",
  "region": "Region Hovedstaden",
  "longitude": 12.5535,
  "latitude": 55.6915,
  "darstatus": 3
}
````

### Use cases

- **CRM data quality** — normalize messy customer-entered Danish addresses into validated records with coordinates.
- **E-commerce checkout** — fuzzy-match partial customer input ("Strandboulevarden 14") to pick the right official address before charging.
- **Delivery routing** — bulk-geocode shipping addresses to feed into route optimization.
- **Real estate & lead enrichment** — tie a Danish street address to its municipality and region for territory assignment.
- **Compliance & KYC** — verify a Danish address actually exists in the official registry.

### Quick start

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

// Forward geocode a list of addresses
const run = await client.actor('nexgendata/denmark-address-validator').call({
  mode: 'forward',
  queries: [
    'Rådhuspladsen 1, 1599 København',
    'Strandboulevarden 14, Aarhus',
    'Nørrebrogade 10'
  ],
  max_results: 3
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

## Reverse geocode a coordinate pair
run = client.actor("nexgendata/denmark-address-validator").call(run_input={
    "mode": "reverse",
    "latitude": "55.6761",
    "longitude": "12.5683",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Frequently asked questions

**Does this work for Faroe Islands and Greenland?**
DAWA covers metropolitan Denmark only. For Faroe Islands or Greenland addresses, you'll need a different source.

**Does it handle apartments and floors?**
Yes — the `floor` and `door` fields surface when DAWA has them. Forward queries with apartment-level input ("Nørrebrogade 10, 3. tv") will match accordingly.

**What's the rate limit?**
DAWA itself has no documented per-IP rate limit, but this actor adds a polite 150ms delay between requests in bulk mode to keep the upstream healthy. Expect ~6 queries/sec sustained.

**Why is reverse geocoding limited to one result?**
Reverse always returns the single closest address — that's how DAWA's `adgangsadresser/reverse` endpoint behaves. To explore neighbors, switch to postcode mode.

**Can I export to Google Sheets / CSV?**
Yes — Apify's dataset export options include CSV, JSON, Excel, HTML, and RSS out of the box. Or pipe results through Make.com / Zapier into your destination of choice.

### Pricing rationale

- **$0.005 per actor start** — covers cold-start container resources.
- **$0.010 per validated address** — Apify free users get $5/month credit, so a free user can validate ~500 Danish addresses/month before topping up. For comparison, Google Maps Geocoding bills ~$5 per 1,000 addresses (plus key/billing setup), Loqate runs $30+ per 1,000. This actor delivers the official Danish source at competitive bulk pricing with zero API-key management overhead.

### About NexGenData

Built by [NexGenData](https://thenextgennexus.com) — we maintain a fleet of 160+ actors targeting markets where the incumbents are either expensive, locked behind enterprise sales, or simply absent. Browse the full catalogue at [thenextgennexus.com](https://thenextgennexus.com).

Found a bug or want a feature? Open an issue on the actor's Apify page or reach out via thenextgennexus.com.

### 💻 Code Example — Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("nexgendata/denmark-address-validator").call(run_input={
    ## Fill in the input shape from the actor's input_schema
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### 🌐 Code Example — cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~denmark-address-validator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ /* input schema */ }'
```

### ❓ FAQ

**Q: How do I get started?**
Sign up at [apify.com](https://www.apify.com/?fpr=2ayu9b), grab your API token from Settings → Integrations, and run the actor via the Apify console, API, Python SDK, or any integration (Zapier, Make.com, n8n).

**Q: What's the typical cost per run?**
See the pricing section below. Most runs finish under $0.10 for typical batches.

**Q: Is this actor maintained?**
Yes. NexGenData maintains 165+ Apify actors and ships updates regularly. Bug reports via the Apify console issues tab get responses within 24 hours.

**Q: Can I use the output commercially?**
Yes — you own the output data. Check the target site's Terms of Service for any usage restrictions on the scraped content itself.

**Q: How do I handle rate limits?**
Apify manages concurrency and retries automatically. For very large batches (10K+ items), run multiple smaller jobs in parallel instead of one mega-job for better reliability.

### 💰 Pricing

Pay-per-event pricing — you only pay for what you actually extract.

- **Actor Start:** $0.0001
- **result:** $0.0050

### 🔗 Related NexGenData Actors

- [Hacker News Scraper](https://apify.com/nexgendata/hacker-news-scraper?fpr=2ayu9b)
- [Google Maps Lead Scraper](https://apify.com/nexgendata/google-maps-scraper?fpr=2ayu9b)
- [SEC EDGAR Scraper](https://apify.com/nexgendata/sec-edgar-scraper?fpr=2ayu9b)

### 🚀 Apify Affiliate Program

New to Apify? Sign up with our [referral link](https://www.apify.com/?fpr=2ayu9b) — you get free platform credits on signup, and you help fund the maintenance of this actor fleet.

### 📚 More From NexGenData

Explore the full catalog, tutorials, Gumroad data packs, and newsletter at **[thenextgennexus.com](https://thenextgennexus.com)** — the brand home for everything we ship.

- 📖 Tutorials & how-to guides
- 🗂️ Full actor catalog with usage examples
- 📦 Gumroad data packs (one-time purchases)
- 📬 Newsletter — monthly drops of new actors and revenue experiments

***

*Built and maintained by [NexGenData](https://apify.com/nexgendata?fpr=2ayu9b) — 165+ actors covering scraping, enrichment, MCP servers, and automation.*
🏠 Home: [thenextgennexus.com](https://thenextgennexus.com)

# Actor input Schema

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

forward = address text → coordinates. reverse = coordinates → address. postcode = list addresses in a Danish postcode.

## `query` (type: `string`):

Address text to search (used in forward mode). Example: 'Nørrebrogade 10, København'

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

Multiple address queries to validate in one run (used in forward mode). Overrides 'query' if provided.

## `max_results` (type: `integer`):

How many matching addresses to return per query (1-100). DAWA fuzzy-matches partial input.

## `latitude` (type: `string`):

Decimal latitude for reverse-geocoding (used in reverse mode). Example: 55.6761

## `longitude` (type: `string`):

Decimal longitude for reverse-geocoding (used in reverse mode). Example: 12.5683

## `postnr` (type: `string`):

4-digit Danish postcode (used in postcode mode). Example: 1050 (central Copenhagen)

## Actor input object example

```json
{
  "mode": "forward",
  "query": "Rådhuspladsen 1, 1599 København",
  "queries": [],
  "max_results": 10,
  "latitude": "55.6761",
  "longitude": "12.5683",
  "postnr": "1050"
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "forward",
    "query": "Rådhuspladsen 1, 1599 København",
    "queries": [],
    "max_results": 10,
    "latitude": "55.6761",
    "longitude": "12.5683",
    "postnr": "1050"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/denmark-address-validator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "forward",
    "query": "Rådhuspladsen 1, 1599 København",
    "queries": [],
    "max_results": 10,
    "latitude": "55.6761",
    "longitude": "12.5683",
    "postnr": "1050",
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/denmark-address-validator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "forward",
  "query": "Rådhuspladsen 1, 1599 København",
  "queries": [],
  "max_results": 10,
  "latitude": "55.6761",
  "longitude": "12.5683",
  "postnr": "1050"
}' |
apify call nexgendata/denmark-address-validator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Denmark Address Validator & Geocoder",
        "description": "Validate, normalize & geocode any Danish address using DAWA — Denmarks official open registry of 2.5M+ addresses. Forward, reverse & postcode lookup with municipality & region codes. No API key needed.",
        "version": "0.0",
        "x-build-id": "n8B92Gi1b7C8qDQE0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~denmark-address-validator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-denmark-address-validator",
                "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/nexgendata~denmark-address-validator/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-denmark-address-validator",
                "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/nexgendata~denmark-address-validator/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-denmark-address-validator",
                "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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "forward",
                            "reverse",
                            "postcode"
                        ],
                        "type": "string",
                        "description": "forward = address text → coordinates. reverse = coordinates → address. postcode = list addresses in a Danish postcode.",
                        "default": "forward"
                    },
                    "query": {
                        "title": "Address query",
                        "type": "string",
                        "description": "Address text to search (used in forward mode). Example: 'Nørrebrogade 10, København'"
                    },
                    "queries": {
                        "title": "Bulk address queries",
                        "type": "array",
                        "description": "Multiple address queries to validate in one run (used in forward mode). Overrides 'query' if provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_results": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many matching addresses to return per query (1-100). DAWA fuzzy-matches partial input.",
                        "default": 10
                    },
                    "latitude": {
                        "title": "Latitude",
                        "type": "string",
                        "description": "Decimal latitude for reverse-geocoding (used in reverse mode). Example: 55.6761"
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "string",
                        "description": "Decimal longitude for reverse-geocoding (used in reverse mode). Example: 12.5683"
                    },
                    "postnr": {
                        "title": "Danish postcode",
                        "type": "string",
                        "description": "4-digit Danish postcode (used in postcode mode). Example: 1050 (central Copenhagen)"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```