# Open Topo Data Elevation Scraper (`parseforge/opentopodata-elevation-scraper`) Actor

Look up terrain elevation for any list of latitude/longitude coordinates using global open elevation datasets (SRTM 30m, NED 10m, EU DEM 25m, ASTER 30m, ETOPO1, EMOD bathymetry, Mapzen, GEBCO, and more). Returns elevation in meters per point with the dataset source and resolution.

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

## Pricing

from $3.75 / 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://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🗻 Open Topo Data Elevation Scraper

> 🚀 **Look up ground elevation for any list of coordinates in seconds.** Pull **terrain altitude in meters** from **11 global elevation datasets** including SRTM 30m, NED 10m, EU-DEM 25m, ASTER 30m, ETOPO1, GEBCO 2020 bathymetry, Mapzen Terrarium, and more. Send a batch of lat/lng pairs, get back elevation, dataset name, and grid resolution per point.

> 🕒 **Last updated:** 2026-05-20 · **📊 7 fields** per record · **🗻 11 elevation datasets** · **🌍 Global coverage** · **📐 8m to 1850m resolution**

The **Open Topo Data Elevation Scraper** turns a list of `{lat, lng}` points into a clean dataset of elevations sampled from world-class open Digital Elevation Models (DEMs). It pulls from **Open Topo Data**, a self-hosted open service that wraps NASA SRTM, USGS NED, ESA Copernicus, NIWA, GEBCO, ETOPO, and other public DEMs into a single uniform interface. The Actor returns **7 clean fields per point**: latitude, longitude, elevation in meters, dataset name, grid resolution in meters, interpolation method, and a timestamp.

Coverage is global. Pick **SRTM 30m** for worldwide land coverage, **NED 10m** for the United States, **EU-DEM 25m** for Europe, **NZDEM 8m** for New Zealand, **GEBCO 2020** for ocean bathymetry, or **ETOPO1** for a coarse but worldwide land + sea model. Each batch is delivered with the dataset attribution and the underlying grid resolution so downstream pipelines know exactly which model produced each number.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| GIS developers, drone planners, hiking & outdoor apps, flood-risk analysts, civil engineers, route planners, weather modellers, environmental scientists | Drone mission elevation profiles, hiking trail gain charts, flood-risk overlays, line-of-sight calculations, watershed analysis, bathymetric route planning |

---

### 📋 What the Open Topo Data Elevation Scraper does

One precise workflow with eleven dataset choices:

- 📍 **Batch elevation lookup.** Send up to many thousands of coordinates per run, get back elevation per point.
- 🌐 **Eleven open elevation models.** SRTM 30m, SRTM 90m, ASTER 30m, NED 10m, NZDEM 8m, EU-DEM 25m, Mapzen Terrarium, EMODnet 2018 bathymetry, GEBCO 2020 bathymetry, ETOPO1, BKG 200m.
- 🧮 **Three interpolation modes.** Bilinear (default), nearest-neighbour, or cubic for smoother results at off-grid coordinates.
- 🪪 **Dataset attribution.** Every record records the dataset that produced the elevation, plus the grid resolution.
- 🚦 **Polite rate-limit handling.** The Actor respects the public service's published rate limit and backs off automatically on 429s.

> 💡 **Why it matters:** elevation is the single most-requested attribute for outdoor routing, drone path planning, and flood modelling, but stitching together the right DEM for each part of the world is a project in itself. This Actor gives you eleven trusted public models behind one consistent record shape.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded elevation dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Coordinates to process. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>dataset</td><td>enum</td><td>"srtm30m"</td><td>One of 11 supported elevation models.</td></tr>
<tr><td>coordinates</td><td>array</td><td>5 famous landmarks</td><td>List of {"lat": number, "lng": number} objects to look up.</td></tr>
<tr><td>interpolation</td><td>enum</td><td>"bilinear"</td><td>Sampling method: bilinear, nearest, or cubic.</td></tr>
<tr><td>customServer</td><td>string</td><td>""</td><td>Optional host override for users running a private elevation server.</td></tr>
</tbody>
</table>

**No login required.** This Actor works against the free public elevation service straight away.

**Example: elevations of the world's tallest summits using SRTM 30m.**

```json
{
    "maxItems": 5,
    "dataset": "srtm30m",
    "coordinates": [
        { "lat": 27.988, "lng": 86.925 },
        { "lat": 35.881, "lng": 76.515 },
        { "lat": 27.700, "lng": 88.146 },
        { "lat": 28.755, "lng": 83.821 },
        { "lat": 27.961, "lng": 86.929 }
    ]
}
````

**Example: U.S. urban benchmarks using high-resolution NED 10m.**

```json
{
    "maxItems": 3,
    "dataset": "ned10m",
    "interpolation": "cubic",
    "coordinates": [
        { "lat": 40.689, "lng": -74.045 },
        { "lat": 37.819, "lng": -122.478 },
        { "lat": 47.620, "lng": -122.349 }
    ]
}
```

> ⚠️ **Good to Know:** the public elevation service is rate-limited to 1 batch per second per source IP. The Actor honours that limit and will back off automatically on a 429 response. For very large runs, expect roughly 100 coordinates per second of throughput.

***

### 📊 Output

Each record contains **7 fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 📍 `latitude` | number | `27.988` |
| 📍 `longitude` | number | `86.925` |
| 🗻 `elevationMeters` | number | null | `8748` |
| 🛰️ `dataset` | string | `"srtm30m"` |
| 📐 `resolutionMeters` | number | null | `30` |
| 🧮 `interpolation` | string | `"bilinear"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-20T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🏔️ Mount Everest summit (SRTM 30m)</strong></summary>

```json
{
    "latitude": 27.988,
    "longitude": 86.925,
    "elevationMeters": 8748,
    "dataset": "srtm30m",
    "resolutionMeters": 30,
    "interpolation": "bilinear",
    "scrapedAt": "2026-05-20T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🗼 Eiffel Tower base, Paris (EU-DEM 25m)</strong></summary>

```json
{
    "latitude": 48.858,
    "longitude": 2.294,
    "elevationMeters": 33,
    "dataset": "eudem25m",
    "resolutionMeters": 25,
    "interpolation": "bilinear",
    "scrapedAt": "2026-05-20T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🌊 Open-ocean bathymetry sample (GEBCO 2020)</strong></summary>

```json
{
    "latitude": -22.951,
    "longitude": -43.210,
    "elevationMeters": -32,
    "dataset": "gebco2020",
    "resolutionMeters": 463,
    "interpolation": "bilinear",
    "scrapedAt": "2026-05-20T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌍 | **Global coverage.** Eleven datasets, including land DEMs for every continent and ocean bathymetry. |
| 📐 | **High-res options.** 8m New Zealand DEM, 10m U.S. NED, 25m Europe DEM, 30m global SRTM. |
| 🌊 | **Bathymetry included.** GEBCO 2020 and EMODnet 2018 give you sea-floor depths anywhere on the planet. |
| 🧮 | **Three sampling modes.** Bilinear, nearest, and cubic interpolation so you can match the precision your application needs. |
| 🪪 | **Provenance on every record.** Dataset name and grid resolution stored per point. |
| 🚦 | **Polite by design.** Honours the public service rate limit and backs off on 429s automatically. |
| 🆓 | **No login.** No personal key required, no signup loop. |

> 📊 Elevation is the single most-requested geospatial attribute for routing, drones, and flood modelling.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Resolution | Setup |
|---|---|---|---|---|---|
| **⭐ Open Topo Data Elevation Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **Global, 11 datasets** | **Live per request** | 8m to 1850m | ⚡ 2 min |
| Commercial elevation services | $99+/month | Global | Live | High | ⏳ Hours |
| Self-hosted DEM tile stack | Servers + storage | Whatever you mirror | Whatever you build | High | 🐢 Days |
| Static gridded CSV downloads | Free | Per-region | Manual | Variable | 🕒 Hours |

Pick this Actor when you want global elevation coverage, no servers to run, and proper dataset attribution on every record.

***

### 🚀 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 Open Topo Data Elevation Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a dataset, an interpolation mode, and supply your `coordinates` list.
4. 🚀 **Run it.** Click **Start** and let the Actor query each batch.
5. 📥 **Download.** Grab your results from 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">

#### 🚁 Drones & aerial work

- Pre-flight elevation profiles for safe altitude planning
- Terrain-following waypoint generation
- Line-of-sight checks between control and aircraft
- Survey-mission ground-sample-distance calibration

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

#### 🥾 Outdoor & fitness apps

- Hiking-trail elevation gain and loss charts
- Cycling-route gradient overlays
- Backcountry skiing slope-angle context
- Run-route difficulty scoring

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

#### 🌊 Flood-risk & insurance

- Property-level above-sea-level scoring
- Watershed runoff modelling inputs
- Coastal-erosion baseline elevation snapshots
- Storm-surge exposure overlays

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

#### 🏗️ Civil engineering & GIS

- Solar-panel siting elevation context
- Cell-tower line-of-sight planning
- Road-grade calculations for logistics routing
- Cut-and-fill volume estimates

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

***

### 🔌 Automating Open Topo Data Elevation Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Nightly batch elevation lookups, on-demand route planning, or live drone-mission preflight checks all run unattended.

***

### 🌟 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

- Glacier-retreat elevation studies
- Geomorphology coursework with real DEM samples
- Reproducible elevation datasets for climate papers
- Cross-DEM comparison studies for accuracy research

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

#### 🎨 Personal and creative

- Personal hiking dashboards and elevation maps
- Indie outdoor app side projects
- Travel-blog elevation profiles for famous routes
- Hobbyist 3D terrain printing input data

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

#### 🤝 Non-profit and civic

- Climate-resilience studies for vulnerable coasts
- Disaster-response staging on high-ground sites
- Watershed advocacy elevation context
- Volunteer trail-stewardship route mapping

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

#### 🧪 Experimentation

- Train terrain-classification ML models
- Prototype agent pipelines that answer "how high is X?"
- Test drone path-planning algorithms with real DEMs
- Benchmark elevation accuracy across datasets

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

***

### 🤖 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%20Open%20Topo%20Data%20Elevation%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%20Open%20Topo%20Data%20Elevation%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%20Open%20Topo%20Data%20Elevation%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%20Open%20Topo%20Data%20Elevation%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

#### 🧩 How does it work?

Supply a list of `{lat, lng}` objects in the input, pick one of the eleven datasets, and click Start. The Actor batches your points, queries the public elevation service in chunks of up to 100, normalises the response, and writes one clean record per point.

#### 🗺️ Which dataset should I pick?

For worldwide land coverage, **SRTM 30m** is the safe default. For the United States, **NED 10m** is higher resolution. For Europe, **EU-DEM 25m**. For New Zealand, **NZDEM 8m**. For oceans, **GEBCO 2020** (global) or **EMODnet 2018** (European seas). For a coarse but worldwide land + sea model, pick **ETOPO1**.

#### 📐 What is the difference between bilinear, nearest, and cubic interpolation?

A coordinate rarely sits exactly on a DEM grid point. **Bilinear** averages the four neighbours and is the default. **Nearest** returns the value of the closest grid point (faster, but step-shaped). **Cubic** smooths across a 4x4 neighbourhood (slower, slightly higher fidelity for gradient analysis).

#### 🚦 What is the rate limit?

The public elevation service allows roughly one batch per second per source IP. The Actor sends batches of 100 coordinates and waits between calls, so a 10,000-point run takes a couple of minutes.

#### 📦 How many coordinates can I send in one run?

Up to 1,000,000 for paid plans. There is no hard per-run cap from the source itself, but very large runs will of course take time because of the polite rate limit.

#### 🆓 Do I need a personal access key?

No. The public service is open and free to use within its rate limit. You only need an Apify account.

#### 💼 Can I use this data commercially?

Yes. The underlying DEMs are public-domain or open-licensed reference data. Each dataset has its own attribution requirements (NASA SRTM, USGS NED, ESA Copernicus, etc.), and the `dataset` field on every record tells you which one was used so you can attribute correctly.

#### ⏰ Can I schedule daily runs?

Yes. Use Apify Schedules to trigger this Actor on any cron interval. Nightly elevation enrichment for new addresses is a common pattern.

#### 💳 Do I need a paid Apify plan?

No. The free Apify plan covers testing and small runs (10 coordinates per run). A paid plan lifts the cap and unlocks scheduling and higher concurrency.

#### 🔁 What happens if a single batch fails?

The Actor retries transient errors automatically. If a batch still fails after retries, the Actor writes one record per coordinate with `elevationMeters: null` and an `error` note, so your downstream pipeline gets a row for every input.

#### 🌊 Does it include ocean depths?

Yes. Pick **GEBCO 2020** for global bathymetry or **EMODnet 2018** for European seas. Negative elevation values are sea floor depth in meters.

#### 🆘 What if I need help?

Contact our support team through the Apify platform or the Tally form linked below.

***

### 🔌 Integrate with any app

Open Topo Data Elevation Scraper 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 elevation data 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 elevations into your drone-planning service, or post a daily route digest into Slack.

***

### 🔗 Recommended Actors

- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap
- [**✈️ OurAirports Global Airport Database Scraper**](https://apify.com/parseforge/ourairports-scraper) - Worldwide aviation reference data
- [**🏕️ Recreation.gov Campsites Scraper**](https://apify.com/parseforge/recreation-gov-campsites-scraper) - U.S. federal recreation catalogue
- [**🌤️ NOAA Weather Scraper**](https://apify.com/parseforge/noaa-weather-scraper) - U.S. weather forecasts and observations
- [**📈 Indexmundi Scraper**](https://apify.com/parseforge/indexmundi-scraper) - Global demographic and economic indicators

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more geospatial scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Open Topo Data, NASA, USGS, ESA, NIWA, GEBCO, NOAA, or any other DEM provider. All trademarks mentioned are the property of their respective owners. Only publicly accessible open elevation data is queried, and the underlying DEMs retain their own attribution requirements.

# Actor input Schema

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

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

## `dataset` (type: `string`):

Source elevation model to query.

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

List of {lat, lng} objects to look up. Example: \[{"lat":27.988,"lng":86.925},{"lat":48.858,"lng":2.294}].

## `interpolation` (type: `string`):

How to sample elevation between grid points.

## `customServer` (type: `string`):

Override the host. Leave blank for the public service.

## Actor input object example

```json
{
  "maxItems": 10,
  "dataset": "srtm30m",
  "coordinates": [
    {
      "lat": 27.988,
      "lng": 86.925
    },
    {
      "lat": 48.858,
      "lng": 2.294
    },
    {
      "lat": 35.681,
      "lng": 139.767
    },
    {
      "lat": -22.951,
      "lng": -43.21
    },
    {
      "lat": 40.689,
      "lng": -74.045
    }
  ],
  "interpolation": "bilinear"
}
```

# 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,
    "dataset": "srtm30m",
    "coordinates": [
        {
            "lat": 27.988,
            "lng": 86.925
        },
        {
            "lat": 48.858,
            "lng": 2.294
        },
        {
            "lat": 35.681,
            "lng": 139.767
        },
        {
            "lat": -22.951,
            "lng": -43.21
        },
        {
            "lat": 40.689,
            "lng": -74.045
        }
    ],
    "interpolation": "bilinear"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/opentopodata-elevation-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,
    "dataset": "srtm30m",
    "coordinates": [
        {
            "lat": 27.988,
            "lng": 86.925,
        },
        {
            "lat": 48.858,
            "lng": 2.294,
        },
        {
            "lat": 35.681,
            "lng": 139.767,
        },
        {
            "lat": -22.951,
            "lng": -43.21,
        },
        {
            "lat": 40.689,
            "lng": -74.045,
        },
    ],
    "interpolation": "bilinear",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/opentopodata-elevation-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,
  "dataset": "srtm30m",
  "coordinates": [
    {
      "lat": 27.988,
      "lng": 86.925
    },
    {
      "lat": 48.858,
      "lng": 2.294
    },
    {
      "lat": 35.681,
      "lng": 139.767
    },
    {
      "lat": -22.951,
      "lng": -43.21
    },
    {
      "lat": 40.689,
      "lng": -74.045
    }
  ],
  "interpolation": "bilinear"
}' |
apify call parseforge/opentopodata-elevation-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open Topo Data Elevation Scraper",
        "description": "Look up terrain elevation for any list of latitude/longitude coordinates using global open elevation datasets (SRTM 30m, NED 10m, EU DEM 25m, ASTER 30m, ETOPO1, EMOD bathymetry, Mapzen, GEBCO, and more). Returns elevation in meters per point with the dataset source and resolution.",
        "version": "1.0",
        "x-build-id": "LTRQ9KoexEA2gGYqK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~opentopodata-elevation-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-opentopodata-elevation-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~opentopodata-elevation-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-opentopodata-elevation-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~opentopodata-elevation-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-opentopodata-elevation-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"
                    },
                    "dataset": {
                        "title": "Elevation Dataset",
                        "enum": [
                            "srtm30m",
                            "srtm90m",
                            "aster30m",
                            "ned10m",
                            "nzdem8m",
                            "eudem25m",
                            "mapzen",
                            "emod2018",
                            "gebco2020",
                            "etopo1",
                            "bkg200m"
                        ],
                        "type": "string",
                        "description": "Source elevation model to query."
                    },
                    "coordinates": {
                        "title": "Coordinates",
                        "type": "array",
                        "description": "List of {lat, lng} objects to look up. Example: [{\"lat\":27.988,\"lng\":86.925},{\"lat\":48.858,\"lng\":2.294}]."
                    },
                    "interpolation": {
                        "title": "Interpolation",
                        "enum": [
                            "bilinear",
                            "nearest",
                            "cubic"
                        ],
                        "type": "string",
                        "description": "How to sample elevation between grid points."
                    },
                    "customServer": {
                        "title": "Custom Server URL (optional)",
                        "type": "string",
                        "description": "Override the host. Leave blank for the public service."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
