DEV Community: Alfiya Tarasenko

How to Build a “What Is My Current Elevation?” Tool with an Elevation API

Alfiya Tarasenko — Thu, 18 Jun 2026 11:26:20 +0000

Have you ever wondered how high above sea level you are right now?
Browsers can tell us a user’s latitude and longitude, but not their elevation. To answer “What is my current elevation?”, we need to get the user’s coordinates first, then send them to an elevation data source.

In this tutorial, we’ll build a small “What Is My Current Elevation?” tool with the Geoapify Elevation API. It will get the current location, request elevation for that point, and display the result in meters.

Try demo in Codepen >>

How It Works

The tool follows a simple workflow:

The browser requests the user's current location through the Geolocation API.
The Geolocation API returns the latitude and longitude coordinates.
Those coordinates are sent to the Geoapify Elevation API.
The API looks up the terrain elevation for that location.
The application displays the elevation value on the page.

In other words, the browser tells us where the user is, and the Elevation API tells us how high above sea level that location is.

 Browser Geolocation API
          ↓
 Latitude / Longitude
          ↓
 Geoapify Elevation API
          ↓
 Elevation Above Sea Level

From Location to Elevation

So, to build a “What Is My Current Elevation?” tool, we need to solve two main tasks:

Get the user’s current location.
Request elevation for that location.

Before we start, it's worth clarifying what elevation actually means.

Elevation is the height of a location above mean sea level. While latitude and longitude describe a position on Earth's surface, elevation adds a third dimension: height. Applications such as hiking apps, route planners, weather tools, and drone software often use elevation data to better understand terrain.

Getting User Location

The first step is getting the user’s coordinates. The browser can do this with the Geolocation API, which returns latitude and longitude for the current device or browser session.

There are two important limitations to keep in mind:

the user must grant location permission;
geolocation may be unavailable or fail in some environments.

Because of that, a production-ready tool should also have a fallback.
A practical fallback is IP geolocation, which estimates a user’s location from their IP address. This fallback is useful, but it is usually less precise than browser geolocation.

Requesting Elevation

Latitude and longitude tell us where the user is, but they don’t tell us how high that location is above sea level. To get that information, we query an elevation dataset through the Geoapify Elevation API.

The API accepts one or more locations and returns elevation values for them. For a “my current elevation” tool, we only need to send one location:

{
  locations: [
    {
      lat: latitude,
      lon: longitude
    }
  ]
}

The response contains the elevation value and units, which we can display in the UI.

So the second part of the app is simple: take the coordinates from the location step, send them to the Elevation API, and render the returned elevation.

At this point, we understand the workflow:

Get the user's coordinates.
Request elevation for those coordinates.
Display the result.

Now let's build a working "What Is My Current Elevation?" tool from scratch.

Building the Tool

Now let’s implement the basic version of the tool with plain HTML, CSS, and JavaScript.

The app will do three things:

Ask the browser for the user’s latitude and longitude.
Send those coordinates to the Geoapify Elevation API.
Show the returned elevation on the page.

We’ll start with the page structure, then add the JavaScript logic step by step.

Add Minimal HTML and CSS

For the basic version, the page only needs a button to start the elevation lookup and a result area to show the response.

<!doctype html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <title>What Is My Current Elevation?</title>
  <style>
    body {
      font-family: Arial, sans-serif;
      margin: 2rem;
    }

    button {
      padding: 0.75rem 1rem;
      cursor: pointer;
    }

    pre {
      margin-top: 1rem;
      padding: 1rem;
      background: #102a43;
      color: #f0f4f8;
      white-space: pre-wrap;
    }
  </style>
</head>
<body>
  <button id="my-elevation-button">My Elevation</button>
  <pre id="elevation-info">Click the button to get your elevation.</pre>

  <script>
    const elevationButton = document.querySelector("#my-elevation-button");
    const elevationInfo = document.querySelector("#elevation-info");

    elevationButton.addEventListener("click", async () => {
      elevationInfo.textContent = "Requesting your location...";

      // Location and elevation logic will go here
    });
  </script>
</body>
</html>

The button will trigger the location request. The <pre> element is useful here because it lets us display multiple lines: elevation, latitude, and longitude.

Get Latitude and Longitude

Now we can add the first JavaScript step: asking the browser for the user’s current coordinates.

The browser Geolocation API uses callbacks, so we’ll wrap it in a Promise to make it easier to use with async / await:

function getCurrentLocation() {
  return new Promise((resolve, reject) => {
    navigator.geolocation.getCurrentPosition(
      (position) => {
        resolve({
          latitude: position.coords.latitude,
          longitude: position.coords.longitude,
        });
      },
      reject,
      {
        enableHighAccuracy: true,
        timeout: 10000,
        maximumAge: 0,
      },
    );
  });
}

This function resolves with an object like this:

{
  latitude: 48.8584,
  longitude: 2.2945
}

These coordinates are the input for the elevation request.

Request Elevation

After we have latitude and longitude, we can send them to the Geoapify Elevation API.

Create a Geoapify API key in the Geoapify My Projects dashboard and replace YOUR_API_KEY with your key:

const apiKey = "YOUR_API_KEY";

async function getElevation(latitude, longitude) {
  const response = await fetch(`https://api.geoapify.com/v1/geodata/elevation?apiKey=${apiKey}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      format: "json",
      units: "metric",
      locations: [
        {
          lat: latitude,
          lon: longitude,
        },
      ],
    }),
  });

  const data = await response.json();
  return data.results[0];
}

The locations field is an array, so the same endpoint can also request elevation for multiple points. For the current elevation tool, we only send one location.

A successful response looks like this:

{
  "results": [
    {
      "location": {
        "lat": 48.8584,
        "lon": 2.2945
      },
      "elevation": 35,
      "units": "m"
    }
  ]
}

In the code above, data.results[0] gives us the elevation result for the first requested location.

Optional: Add an IP Geolocation Fallback

Browser geolocation gives better results, but it depends on user permission. If the user denies the request, or if geolocation is unavailable, we can fall back to IP geolocation.

IP geolocation is usually less precise than browser geolocation because it estimates location from the user’s network connection, not from the device itself. Still, it is useful as a backup when exact location is not available.

async function getLocationFromIp() {
  const response = await fetch(`https://api.geoapify.com/v1/ipinfo?apiKey=${apiKey}`);
  const result = await response.json();

  return {
    latitude: result.location.latitude,
    longitude: result.location.longitude,
  };
}

Then update the location function to use browser geolocation first and IP geolocation as a fallback:

async function getCurrentLocation() {
  if (!("geolocation" in navigator)) {
    return getLocationFromIp();
  }

  return new Promise((resolve) => {
    navigator.geolocation.getCurrentPosition(
      (position) => {
        resolve({
          latitude: position.coords.latitude,
          longitude: position.coords.longitude,
        });
      },
      () => {
        resolve(getLocationFromIp());
      },
      {
        enableHighAccuracy: true,
        timeout: 10000,
        maximumAge: 0,
      },
    );
  });
}

Wire Everything Together

Now we can connect everything to the button. On click, the app gets the current location, sends it to the Elevation API, and writes the result to the page.

The click handler looks like this:

elevationButton.addEventListener("click", async () => {
  elevationInfo.textContent = "Requesting your location...";

  const location = await getCurrentLocation();

  elevationInfo.textContent = "Requesting elevation...";

  const elevation = await getElevation(location.latitude, location.longitude);

  elevationInfo.textContent = [
    `Elevation: ${elevation.elevation} ${elevation.units}`,
    `Latitude: ${location.latitude}`,
    `Longitude: ${location.longitude}`,
  ].join("\n");
});

Going Further

The minimal version shows the core idea: get coordinates, request elevation, and display the result.

From here, you can extend the tool in several useful ways:

show the selected location on an interactive map with Geoapify Map Tiles and MapLibre GL JS;
let users click the map to request elevation for any point;
use IP geolocation as a fallback when browser geolocation is unavailable;
request elevation for multiple locations in one API call;
visualize elevation across a city or the current map view.

You can see these ideas in the full demo:

Open the “What Is My Current Elevation?” demo >>

Conclusion

A current elevation tool is mostly a coordinate lookup followed by an elevation lookup. The browser Geolocation API gives us latitude and longitude, and the Geoapify Elevation API turns those coordinates into elevation above sea level.

From there, you can keep the tool simple or expand it with maps, click-based lookup, IP geolocation fallback, and multi-point elevation requests.

Try the complete demo on CodePen, or create a free Geoapify API key and build your own version:

Route optimization is more than finding the shortest route. Learn how VRPs, constraints, optimization algorithms, APIs, and tools like OR-Tools and VROOM work together to solve real-world delivery and logistics challenges.

Alfiya Tarasenko — Fri, 05 Jun 2026 12:43:19 +0000

Alfiya Tarasenko for Geoapify Maps API

Jun 5

What Is Route Optimization? Algorithms, APIs, and Open-Source Tools

#algorithms #programming #logistics #api

8 min read

What Is Route Optimization? Algorithms, APIs, and Open-Source Tools

Alfiya Tarasenko — Fri, 05 Jun 2026 12:42:37 +0000

Whether you’re building a delivery platform, a field service application, or a logistics solution, you’ll eventually face the same challenge: finding the best route for multiple stops.

At first glance, the problem seems straightforward. Just visit all stops while minimizing travel time or distance.

In reality, route optimization quickly becomes complex. Even a route with 10 stops can have millions of possible combinations, and real-world constraints such as delivery time windows, vehicle capacities, driver schedules, and pickup-and-delivery requirements make the problem even harder.

In this article, we'll cover:

What route optimization is
How route optimization problems are modeled with VRP
Algorithms used to solve route optimization problems
Ready-to-use route optimization applications
Route Optimization APIs
Open-source route optimization tools
How to choose the right solution

What Is Route Optimization?

Route optimization is the process of finding the most efficient routes for one or more vehicles while satisfying a set of constraints.

The goal is typically to minimize travel time, distance, or operational costs while ensuring that all required stops are visited.

Unlike simple routing, route optimization is not just about finding the shortest path between two points. It must also determine the order in which stops should be visited, assign stops to vehicles, and satisfy various operational constraints.

Routing focuses on finding a path between locations. Route optimization focuses on finding the best set of routes while satisfying real-world constraints.

Common constraints include:

Vehicle capacities
Delivery time windows
Driver schedules
Pickup and delivery requirements

As the number of stops and constraints grows, route optimization becomes increasingly difficult to solve.

Modeling Route Optimization with VRP

As route optimization problems become larger and more complex, they require a formal way to represent vehicles, stops, objectives, and constraints.

In operations research and computer science, these challenges are commonly modeled as the Vehicle Routing Problem (VRP).

Over the years, numerous VRP variants have been developed to represent different real-world requirements:

Problem Type	Description	Common Constraints
Vehicle Routing Problem (VRP)	The basic problem of assigning locations to vehicles and determining the best visit order.	Travel time, distance, cost
Capacitated Vehicle Routing Problem (CVRP)	Vehicles have limited capacity, such as weight, volume, or number of packages.	Vehicle capacity, load balancing
Vehicle Routing Problem with Time Windows (VRPTW)	Deliveries or visits must occur within specified time windows.	Delivery windows, service duration, driver schedules
Pickup and Delivery Problem (PDP)	Items must be picked up at one location and delivered to another.	Pickup-before-delivery, vehicle capacity
Multi-Depot Vehicle Routing Problem (MDVRP)	Vehicles can start and end at different depots.	Depot assignment, vehicle availability
Open Vehicle Routing Problem (OVRP)	Vehicles do not need to return to their starting depot.	End location flexibility
Periodic Vehicle Routing Problem (PVRP)	Customers require visits on specific days according to a schedule.	Visit frequency, planning horizon
Dynamic Vehicle Routing Problem (DVRP)	New jobs or changes can occur while routes are already in progress.	Real-time updates, traffic, new orders

Most real-world route optimization systems combine several of these variants. For example, a delivery application may need to handle vehicle capacities, customer time windows, multiple depots, pickup-and-delivery operations, driver shifts, breaks, and priority deliveries simultaneously.

How Route Optimization Is Solved

Route optimization belongs to a class of computationally difficult problems. As the number of stops increases, the number of possible route combinations grows exponentially, making it impractical to evaluate every possible solution.

For example:

5 stops → 120 possible routes
10 stops → 3.6 million possible routes
20 stops → over 2 quintillion possible routes

And that's before considering multiple vehicles, time windows, capacities, or other constraints.

Because of this, route optimization systems rely on specialized algorithms that search for high-quality solutions without evaluating every possible route.

Exact Algorithms

Exact algorithms guarantee the optimal solution. Common approaches include:

Algorithm	Description	Best For
Branch and Bound	Systematically explores possible solutions while pruning suboptimal branches.	Small to medium-sized optimization problems
Mixed Integer Programming (MIP)	Models route optimization using variables, objectives, and constraints solved mathematically.	Complex optimization problems with many business constraints

These methods systematically explore the solution space while using mathematical techniques to eliminate suboptimal solutions.

While highly accurate, exact algorithms become computationally expensive as the number of stops, vehicles, and constraints grows. As a result, they are typically used for smaller optimization problems or as benchmarks for evaluating other approaches.

Heuristics and Metaheuristics

Most modern route optimization systems rely on heuristics and metaheuristics that can find high-quality solutions much faster than exact algorithms.

Common approaches include:

Algorithm	Description	Best For
Clarke-Wright Savings Algorithm	A classic heuristic that builds routes by merging stops in a way that maximizes travel savings.	Quickly generating initial solutions for routing problems
Local Search	Starts with an existing solution and iteratively improves it by making small changes.	Refining and improving existing routes
Tabu Search	An advanced local search technique that avoids revisiting recently explored solutions.	Large optimization problems with many local optima
Simulated Annealing	Occasionally accepts worse solutions to escape local optima and explore more of the search space.	Complex optimization problems where local search may get stuck
Genetic Algorithms	Inspired by biological evolution, combining and mutating solutions over multiple generations.	Large-scale optimization problems with many constraints

Rather than evaluating every possible route, these methods intelligently explore the search space and iteratively improve solutions.

While they do not guarantee the mathematically optimal result, they can often find near-optimal solutions in seconds, making them well suited for large-scale route optimization problems involving hundreds or thousands of stops.

In practice, many route optimization systems combine multiple techniques. For example, a solver may generate an initial route using a heuristic and then improve it using local search or other metaheuristic methods.

Route Optimization Solutions

Fortunately, you don't need to implement route optimization algorithms from scratch. A wide range of solutions already exists, from business applications designed for non-technical users to open-source solvers and Route Optimization APIs that can be integrated directly into your applications.

Ready-to-Use Applications

Ready-to-use route optimization applications provide a complete solution for planning and managing routes. They typically include route optimization, driver management, dispatching, tracking, and reporting features through a web interface, allowing businesses to start optimizing routes without writing any code.

Product	Description	Best For
OptimoRoute	Route planning and field service management platform with route optimization, scheduling, and tracking capabilities.	Delivery businesses and field service teams
Onfleet	Last-mile delivery management platform focused on dispatching, driver tracking, and route optimization.	Delivery and logistics companies
Routific	Cloud-based route optimization software designed for delivery operations.	Small and medium-sized delivery fleets
Circuit for Teams	Route planning platform with driver apps, dispatch tools, and route optimization.	Local delivery businesses
RouteXL	Online route optimization tool that helps plan multi-stop routes through a simple web interface.	Small businesses and occasional route planning
MyRouteOnline	Route planning software that optimizes routes from spreadsheets and address lists.	Businesses managing routes from Excel or CSV files

These platforms are ideal when you need route optimization as a business tool. However, if you're building your own application or need complete control over the optimization process, open-source route optimization engines may be a better fit.

Route Optimization APIs

Route Optimization APIs provide route optimization capabilities through a web service, allowing developers to integrate optimization directly into their applications without managing optimization engines or infrastructure.

Most APIs accept a list of locations, vehicles, and constraints, then return optimized routes, stop assignments, and scheduling information.

API	Description	Best For
Geoapify Route Optimization API	Route optimization API supporting multiple vehicles, capacities, time windows, pickup and delivery operations, and route balancing.	Applications that need route optimization without managing infrastructure
Google Route Optimization API	Enterprise-grade route optimization service built on Google's mapping and routing infrastructure.	Large-scale logistics and enterprise applications
NextBillion.ai Route Optimization API	Optimization API focused on logistics, dispatching, and delivery operations.	Logistics and delivery applications

Advantages

Route Optimization APIs are often the fastest way to add optimization capabilities to an application. They eliminate the need to implement complex algorithms, manage optimization infrastructure, or maintain routing engines.

Key benefits include:

Fast integration
No infrastructure to manage
No solver expertise required
Automatically updated and maintained
Scales with application usage

Challenges

Like any managed service, Route Optimization APIs come with trade-offs. While they significantly reduce development and operational effort, they may not provide the same level of control as self-hosted solutions.

Common considerations include:

Usage-based pricing
Less flexibility than self-hosted solutions
Limited access to underlying optimization logic

Open-Source Route Optimization Tools

For developers who need complete control over the optimization process, open-source route optimization tools provide a flexible alternative to commercial applications and managed APIs.

These tools implement many of the algorithms discussed earlier and can be integrated into custom applications, self-hosted platforms, or research projects.

Tool	Language	Description	Best For
Google OR-Tools	C++, Python, Java, C#	Comprehensive optimization toolkit that includes powerful Vehicle Routing Problem (VRP) solvers and support for many routing constraints.	Custom optimization applications and research
VROOM	C++	High-performance route optimization engine designed specifically for vehicle routing problems. Integrates with routing engines such as OSRM, Valhalla, and Openrouteservice.	Logistics and delivery platforms
jsprit	Java	Java toolkit for solving vehicle routing problems with support for capacities, time windows, and custom constraints.	Java-based route optimization applications

Google's OR-Tools is one of the most widely used open-source optimization frameworks and is frequently used for solving Vehicle Routing Problems.

Advantages

Open-source tools provide maximum flexibility and allow organizations to fully control how route optimization is implemented and deployed.

Key benefits include:

No per-request usage fees
Full control over optimization logic
Ability to customize constraints and objectives
Self-hosted deployment
Access to source code

Challenges

Using open-source solvers typically requires more engineering effort than ready-to-use applications or APIs.

Common considerations include:

Infrastructure and deployment management
Integration with routing engines
Building a distance matrix or travel time matrix for all locations
Solver configuration and tuning
Maintenance and upgrades
Additional development effort

Many route optimization engines, including VROOM and OR-Tools, rely on a travel time or distance matrix that describes the cost of traveling between every pair of locations. Generating this matrix can be computationally expensive and typically requires integration with a routing service.

For example, the Geoapify Route Matrix API can generate travel time and distance matrices that can then be used as input for route optimization engines.

How to Choose the Right Solution

The best route optimization solution depends on how much control and customization you need.

If you want to...	Recommended Solution
Start optimizing routes immediately without development	Ready-to-use application
Give dispatchers and drivers a complete route planning solution	Ready-to-use application
Add route optimization to an existing application	Route Optimization API
Build a custom route optimization workflow	Route Optimization API
Self-host the optimization engine	Open-source tool
Customize optimization logic and constraints	Open-source tool
Experiment with optimization algorithms	Open-source tool
Avoid managing infrastructure and optimization engines	Route Optimization API
Have full control over the optimization process	Open-source tool

In Summary

Choose a ready-to-use application if you want to optimize routes without writing code or managing technical infrastructure.
Choose a Route Optimization API if you're building an application and need route optimization capabilities without implementing optimization algorithms yourself.
Choose an open-source tool if you need maximum flexibility, self-hosting, or complete control over the optimization process.

There is no universally best route optimization solution. The right choice depends on whether your priority is ease of use, rapid integration, or maximum flexibility. Understanding the trade-offs between applications, APIs, and open-source tools will help you choose a solution that matches both your technical requirements and business goals.

Need to geocode thousands of addresses but don’t want to pay? This guide compares 4 practical approaches: online tools, geocoding APIs, batch geocoding, and self-hosted solutions—with free limits, examples, and trade-offs.

Alfiya Tarasenko — Thu, 04 Jun 2026 09:28:32 +0000

Alfiya Tarasenko for Geoapify Maps API

Jun 4

How to Geocode Thousands of Addresses for Free

#geocoding #gis #data #javascript

9 min read

How to Geocode Thousands of Addresses for Free

Alfiya Tarasenko — Thu, 04 Jun 2026 09:27:46 +0000

Geocoding large address datasets (finding latitude and longitude coordinates for addresses) can quickly become expensive, especially when you need to process hundreds or thousands of records. This can be a challenge for businesses, researchers, and individuals working with limited budgets.

Fortunately, there are several ways to geocode thousands of addresses completely free of charge, and in this article we’ll explore the most practical options.

How to Geocode Thousands of Addresses for Free

Yes. While most geocoding services charge based on usage, many providers offer free quotas that are large enough for one-time projects, research, testing, and small business needs.

Note: "Free" does not necessarily mean unlimited. Most services apply daily quotas, rate limits, or file-size restrictions. In some cases, free usage may require more effort, such as splitting large datasets into smaller batches, waiting for daily quotas to reset, or processing data over multiple days.

However, with the right approach, these limits are often sufficient to geocode thousands—or even tens of thousands—of addresses without spending money.

The exact limits depend on the approach you choose. Here are three practical ways to geocode thousands of addresses for free:

Method	Free Limit	Best For
Online Tool	2,500 addresses per run	CSV files, no coding
Geocoding API	3,000 addresses/day	Applications and automation
Batch Geocoding API	Up to 6,000 addresses/day (priority 0.5)	Large datasets
Self-Hosted Geocoder	Depends on your infrastructure	Very large datasets

Let's take a closer look at each option and see when it makes the most sense to use it.

Method #1: Use an Online Geocoding Tool

The simplest way to geocode a large address dataset is to use an online geocoding tool. This approach requires no coding, no API integration, and no software installation. You simply upload a CSV or Excel file containing addresses and download the results.

For example, GeoSearch Online allows you to upload CSV and Excel files and geocode up to 2,500 addresses per run for free. The service returns latitude and longitude coordinates along with standardized address information and other useful location data.

Upload a CSV or Excel file containing addresses and geocode up to 2,500 records for free.

How it works

Export your address list to a CSV or Excel file.
Upload the file to GeoSearch Online.
Select the address column to geocode.
Start the geocoding process.
Download the resulting file with coordinates.

Example

The following example shows how a list of addresses can be enriched with coordinates and standardized address data.

Before geocoding:

original_address
1 Apple Park Way, Cupertino, CA
350 5th Ave, New York, NY

After geocoding:

original_address	lat	lon	formatted
1 Apple Park Way, Cupertino, CA	37.3302112	-122.010771	1 Apple Park Way, Cupertino, CA 94087, United States of America
350 5th Ave, New York, NY	40.7484421	-73.9856589	Empire State Building, 350 5th Avenue, New York, NY 10118, United States of America

In addition to latitude and longitude coordinates, geocoding services often return standardized address components such as house numbers, street names, postcodes, cities, states, countries, and confidence scores. This enriched data can help with address validation, data cleaning, analytics, and mapping applications.

Summary

Pros	Cons
• No coding required • Works directly with CSV and Excel files • Fast and easy to use • Suitable for one-time projects	• Requires manual file upload • Large datasets may need to be split into multiple files • Not suitable for automated workflows

Free Limit: Up to 2,500 addresses per run.

Best for: Businesses, researchers, students, and anyone who needs to geocode a spreadsheet without writing code.

Method #2: Use a Geocoding API

If you need to geocode addresses regularly or integrate geocoding into an application, a geocoding API is often a better choice than an online tool. Instead of uploading files manually, your application sends addresses directly to the API and receives the results programmatically.

Unlike online tools that process an entire file at once, geocoding APIs typically work synchronously. Your application sends an address, waits for the response, and immediately receives latitude, longitude, and standardized address information. This makes APIs a great choice for websites, mobile apps, internal tools, and automated workflows that require real-time geocoding.

For example, the Geoapify Geocoding API provides up to 3,000 free requests per day.

How it works

Create a free account at Geoapify and obtain an API key.
Send an address and your API key to the geocoding API.
The API searches for the best matching location.
Receive latitude, longitude, and additional address details in the response.
Store or use the results in your application.

Example: Geocode a Single Address

const apiKey = "YOUR_API_KEY";

const address = "1 Apple Park Way, Cupertino, CA";

fetch(
  `https://api.geoapify.com/v1/geocode/search?text=${encodeURIComponent(address)}&apiKey=${apiKey}`
)
  .then(response => response.json())
  .then(result => {
    console.log(result.features[0].properties);
  });

The response contains coordinates, a formatted address, and additional location details that can be used for mapping, analytics, and address validation.

Respecting Rate Limits

Since each address requires a separate API request, it’s important to respect the API’s rate limits.

For example, the Geoapify free plan allows up to 5 requests per second and 3,000 requests per day. A rate-limiting library can help automatically distribute requests over time.

Example: Using a Rate Limiter

The @geoapify/request-rate-limiter package helps distribute requests according to your plan limits.

const RequestRateLimiter = require('@geoapify/request-rate-limiter');

const apiKey = 'YOUR_API_KEY';

// Function that geocodes a single address
async function geocodeAddress(address) {
    const response = await fetch(
        `https://api.geoapify.com/v1/geocode/search?text=${encodeURIComponent(address)}&apiKey=${apiKey}`
    );

    return await response.json();
}

// List of addresses to geocode
const addresses = [
    "1 Apple Park Way, Cupertino, CA",
    "350 5th Ave, New York, NY",
    "1600 Amphitheatre Parkway, Mountain View, CA"
];

// Convert each address into a request function
const requests = addresses.map(address => {
    return () => geocodeAddress(address);
});

// Process requests while respecting rate limits
RequestRateLimiter.rateLimitedRequests(
    requests,
    5,      // Maximum requests per interval
    1000    // Interval duration in milliseconds
)
.then(results => {
    console.log('All addresses processed');
    console.log(results);
})
.catch(error => {
    console.error('Error processing requests:', error);
});

Summary

Pros	Cons
• Easy to automate • Integrates directly into applications and scripts • Returns results immediately • No manual file uploads	• Requires programming knowledge • Daily usage limits apply • Requests must respect rate limits • Large datasets may take time to process

Free limit: Up to 3,000 requests per day.

Best for: Applications, websites, scripts, and automated workflows that need real-time geocoding.

Method #3: Use a Batch Geocoding API

If you need to geocode thousands of addresses at once, a batch geocoding API can be more efficient than sending individual requests through a standard geocoding API.

Unlike synchronous APIs that process one address per request and return results immediately, batch geocoding APIs work asynchronously. You submit a large set of addresses as a job, wait for the processing to complete, and then download the results. This approach is designed specifically for large datasets and avoids the need to manage thousands of individual requests.

For example, the Geoapify Batch Geocoding API allows you to submit up to 1,000 addresses per job. If your dataset is larger, you can simply submit multiple batch jobs and process them independently.

An additional advantage of batch geocoding is the priority parameter. Lower-priority jobs cost fewer credits because they are processed when system resources are available. For example, using a priority=0.5 reduces the processing cost by 50%. As a result, the free plan’s daily quota can process up to 6,000 addresses per day instead of 3,000.

How it works

Create a free account at Geoapify and obtain an API key.
Prepare a list of addresses to geocode.
Submit the addresses as a batch job.
Wait for the job to complete.
Download the results containing coordinates and standardized address information.

Example: Batch Geocoding with a Library

While you can work directly with the Batch Geocoding API, using the @geoapify/batch-geocoding library simplifies the asynchronous workflow by handling job creation, polling, and result retrieval.

import { Batcher } from "@geoapify/batch-geocoding";

// Create SDK client with your API key
const batcher = new Batcher("YOUR_API_KEY");

// Submit a batch geocoding job
const job = batcher.geocode(
  [
    {
      text: "1000 5th Ave, New York, NY 10028, United States"
    },
    {
      text: "11 W 53rd St, New York, NY 10019, United States"
    },
    /* Up to 1,000 addresses can be submitted in a single batch job*/
  ],
  {
    priority: 0.5 // Lower-priority processing
  }
);

// Wait for processing to complete and retrieve results
const jsonResult = await job.getResults().then(result => result.json());

console.log(jsonResult);

The library submits the batch job, waits for processing to complete, and returns the geocoding results, making it much easier to work with large datasets.

Summary

Pros	Cons
• Designed for large datasets • Processes many addresses in a single job • Higher free throughput than synchronous APIs • Supports discounted low-priority processing	• Results are not immediate • Requires programming knowledge • Jobs may take time to complete • Not suitable for real-time geocoding

Free limit: Up to 3,000 addresses per day, or up to 6,000 addresses per day when using priority=0.5.

Best for: Large address datasets, data enrichment projects, migrations, and bulk geocoding workflows.

Method #4: Use a Self-Hosted Geocoding Engine

If you need complete control over your geocoding infrastructure or want to process very large datasets without API quotas, you can run an open-source geocoding engine on your own server.

Unlike hosted geocoding services, self-hosted solutions require you to install, configure, and maintain the software, as well as regularly update the underlying geographic data. In return, you are not limited by API quotas and can process as many addresses as your hardware can handle.

Several mature open-source geocoding engines are available:

Engine	Description	Documentation	Installation
Nominatim	The most widely used OpenStreetMap geocoder	Docs	Install
Pelias	A highly scalable geocoder built for large deployments	Docs	Install
Photon	A lightweight geocoder based on OpenStreetMap data and Elasticsearch	Docs	Install

While self-hosting removes usage limits, it introduces infrastructure costs and operational complexity. Importing and indexing OpenStreetMap data can require significant disk space, memory, and processing time, depending on the geographic area covered.

Summary

Pros	Cons
• No API quotas • Full control over data and infrastructure • Suitable for very large datasets • Can be integrated into internal systems	• Requires server infrastructure • Installation and maintenance effort • Data updates must be managed manually • Results may vary depending on data quality and configuration • Higher technical complexity

Free limit: No API quotas. Limited only by your infrastructure.

Best for: Organizations processing large volumes of addresses, companies with strict data requirements, and teams that need full control over their geocoding infrastructure.

Which Method Should You Choose?

The best option depends on your dataset size, technical skills, and automation requirements.

Method	Free Limit	Coding Required	Best For
Online Tool	2,500 addresses per run	No	One-time CSV or Excel processing
Geocoding API	3,000 addresses per day	Yes	Applications and automation
Batch Geocoding API	Up to 6,000 addresses per day (priority 0.5)	Yes	Large datasets
Self-Hosted Geocoder	Depends on infrastructure	Yes	Very large datasets and full control

Choose an online geocoding tool if you have a spreadsheet and need a quick, no-code solution.
Choose a geocoding API if you need real-time geocoding in an application, website, or automated workflow.
Choose a batch geocoding API if you need to process thousands of addresses efficiently and don't need immediate results.
Choose a self-hosted geocoding engine if you need full control over your infrastructure and are prepared to manage the software and data yourself.

For most users, an online tool is the easiest place to start. If you need automation, APIs provide more flexibility, while batch processing and self-hosted solutions are better suited for large-scale geocoding projects.

Conclusion

Geocoding thousands of addresses for free is entirely possible. Whether you prefer a simple online tool, a geocoding API, a batch processing service, or a self-hosted solution, the best choice depends on your dataset size, automation requirements, and technical expertise.

For most users, an online tool is the easiest option, while APIs and batch processing provide more flexibility for larger and recurring geocoding tasks.

Related Resources

Confused between Routing APIs and Route Optimization APIs? This guide breaks down the difference with clear examples, a side-by-side comparison, and when to use each in real applications.

Alfiya Tarasenko — Mon, 20 Apr 2026 12:12:12 +0000

Alfiya Tarasenko for Geoapify Maps API

Apr 20

What Is the Difference Between a Routing API and a Route Optimization API?

#api #maps #routing #appdev

4 min read

What Is the Difference Between a Routing API and a Route Optimization API?

Alfiya Tarasenko — Mon, 20 Apr 2026 12:11:30 +0000

If you're building a map-based or logistics application, you’ll likely come across two terms that sound very similar: Routing API and Route Optimization API.

At first glance, they may seem interchangeable. Both deal with routes, distances, and travel time. But in practice, they solve very different problems.

In simple terms

A routing API calculates the path between given points and returns the actual route (geometry, distance, time)
A route optimization API determines the most efficient order of stops, without necessarily returning full route geometry

For example, a routing service like the Geoapify Routing API helps you build directions from point A to point B, from B to C, and so on — following a predefined order.

In contrast, the Geoapify Route Optimization API is designed to organize multiple stops — even across multiple vehicles — into the most efficient routes.

In this article, we’ll break down the difference step by step, compare how each API works, and show when to use one over the other.

What is a Routing API?

A routing API is used to calculate the path between locations in a predefined order.

You provide a list of waypoints, and the API returns the route that connects them — including distance, estimated travel time, and often turn-by-turn instructions.

Key characteristics

Works with a fixed sequence of points (A → B → C)
Returns full route geometry (coordinates for map display)
Provides distance and travel time
Can include turn-by-turn navigation instructions
Supports different travel modes (driving, walking, cycling, etc.)
Allows avoiding specific route parts (tolls, highways, ferries, etc.)
Can provide additional details like road type, surface, and other route attributes

Example use cases

Showing directions from a user’s location to a destination
Displaying a route on a map
Building navigation features in apps

Try it yourself

You can test routing requests in the. Geoapify API Playground: enter a few waypoints and see how the API builds a route step by step.

What is a Route Optimization API?

A route optimization API is designed to find the most efficient way to visit multiple locations.

Instead of following a predefined order, you provide a list of stops, and the API determines the best sequence to minimize travel time, distance, or overall cost.

Key characteristics

Works with an unordered set of locations
Optimizes the sequence of stops
Supports multiple vehicles and route assignments
Focuses on efficiency (time, distance, cost)
Can handle constraints like time windows, capacities, or working hours
Does not necessarily return full route geometry (focus is on planning)

Example use cases

Delivery route planning
Field service scheduling
Logistics and fleet management
Last-mile delivery optimization

Try it yourself

You can experiment with route optimization in the Geoapify API Playground: generate a task, visualize it on the map, solve it, and check the optimized result.

Routing API vs Route Optimization API

The difference between these two APIs is easiest to understand when viewed side by side:

Feature	Routing API	Route Optimization API
Main goal	Calculate a route between points	Find the most efficient order of stops
Input	Ordered waypoints (A → B → C)	Unordered locations (optionally with multiple vehicles)
Output	Route geometry, distance, time	Optimized sequence + route assignments
Focus	Navigation	Planning & efficiency
Usage	Route planning and live navigation	Route planning
Multi-vehicle support	❌ No	✅ Yes
Constraints (time windows, capacity, shifts)	❌ No	✅ Yes

Key takeaway

Routing API → connects points in a given order
Route Optimization API → determines the best order of points

In short: routing builds routes, optimization plans them.

When to Use Each API

Choosing between a Routing API and a Route Optimization API depends on the problem you’re solving.

Use a Routing API if:

You need directions between points
The order of stops is already known
You want to display routes on a map
You are building navigation features (including live navigation)

Example:

Show directions from a user’s location to a destination, or follow a predefined route A → B → C.

Use a Route Optimization API if:

You have multiple stops and the order is not fixed
You want to minimize travel time, distance, or cost
You need to plan routes for multiple vehicles
You have constraints like time windows or capacity

Example:

Plan delivery routes for 20 addresses across several drivers.

Use both together (common in real apps)

In many applications, these APIs are combined:

Route Optimization API → determines the best order of stops
Routing API → builds the actual routes between those stops

In practice, you often need to use a Routing API after optimization to generate routes between the optimized waypoints, visualize them on a map, or provide navigation instructions.

This approach gives you both efficiency and detailed route information.

Conclusion

Routing APIs and Route Optimization APIs may sound similar, but they solve fundamentally different problems.

Routing API → calculates how to get from one point to another
Route Optimization API → decides the best order to visit multiple points

If your app needs directions or navigation, a Routing API is the right choice.

If you’re planning deliveries, field service routes, or logistics workflows, you’ll need a Route Optimization API.

In many real-world applications, the best solution is to use both:

Optimization to plan the route
Routing to build and display it

Understanding this difference helps you choose the right tool, avoid unnecessary complexity, and build more efficient applications.

Try it yourself

Want to see the difference in action?

Routing API → https://apidocs.geoapify.com/playground/routing/
Route Optimization API → https://apidocs.geoapify.com/playground/route-planner/

Create a simple route and then try optimizing multiple stops — the difference becomes immediately clear.

Why does reverse geocoding return a slightly different address than where you click? This article explains why it happens, how distance is calculated, and how to handle it in your app — with a live demo.

Alfiya Tarasenko — Wed, 15 Apr 2026 12:26:19 +0000

Alfiya Tarasenko for Geoapify Maps API

Apr 15

Why Reverse Geocoding Doesn’t Return the Exact Clicked Location

#reverse #geocoding #gis #api

4 min read

Why Reverse Geocoding Doesn’t Return the Exact Clicked Location

Alfiya Tarasenko — Wed, 15 Apr 2026 00:42:58 +0000

When you click on a map and request an address for that exact point, you might expect a perfect match.

But in practice, the returned address can differ slightly from the location you clicked — sometimes by just a few meters, sometimes more.

If you’ve noticed this behavior in your app, you’re not dealing with a bug. It’s a natural result of how reverse geocoding works.

In this article, we’ll explore why the address you get doesn’t always exactly match the clicked map point, and what this means when building map-based applications.

This example uses a simple map demo powered by the Geoapify Reverse Geocoding API , so you can see this behavior in action.

👉 CodePen demo / code sample

What Reverse Geocoding Actually Returns

Reverse geocoding doesn’t return the exact point you clicked.

Instead, it returns the closest known addressable location in the dataset. That’s a key difference.

Coordinates represent a continuous space — every point on the map has a latitude and longitude.

Addresses, on the other hand, are discrete. They only exist where real-world objects are defined:

buildings
entrances
parcels
points of interest

So when you click somewhere on the map, the system has to answer a different question:

“What is the nearest meaningful address to this point?”

Not:

“What exists exactly at this coordinate?”

What this means in practice

Clicking on a road → returns a nearby building or street address
Clicking inside a park → returns the nearest street or POI
Clicking near a building → returns the building’s registered address point

Even if the difference is just a few meters, it’s expected behavior.

How Far Is the Returned Location from the Clicked Point?

Once you understand that reverse geocoding returns the nearest address, the next logical question is:

How far is the returned result from the original point?

There isn’t just one answer — because there are two different ways to measure distance.

1. Distance to the Returned Object (Geometry Distance)

When the returned result represents a building or boundary, the distance is calculated between:

your clicked point
and the geometry (polygon) of that object

This leads to an important detail:

👉 If your point is inside the building polygon, the distance can be 0,

even if the returned coordinate (for example, the entrance) is several meters away:

{
  "results": [
    {
      "country": "Germany",
      "city": "Nuremberg",
      "postcode": "90425",
      "street": "Pretzfelder Straße",
      "housenumber": "15",
      "lon": 11.064715,
      "lat": 49.4718661,
      "result_type": "building",
      "formatted": "Pretzfelder Straße 15, 90425 Nuremberg, Germany",
      "distance": 0
    }
  ],
  "query": {
    "lat": 49.47177742331178,
    "lon": 11.064803253993091
  }
}

Example:

You click inside a large building
The address is tied to the entrance
The API may report distance = 0 (because you are inside the building)
But visually, the returned point is offset

2. Real Distance Between Coordinates

This is the actual distance between:

the clicked point
and the returned coordinate

This is what you usually need if you want to measure the visible offset.

Option 1: Haversine Formula

You can calculate the distance between two coordinates using the Haversine formula:

d = 2r * arcsin(√(sin²((lat2 - lat1) / 2) + cos(lat1) * cos(lat2) * sin²((lon2 - lon1) / 2)))

Where:

lat1, lon1 = clicked point
lat2, lon2 = returned location
r = Earth radius (≈ 6371 km)

Option 2: Using Turf.js

If you're working in JavaScript, you can use a geospatial library like Turf.js to calculate distances easily.

@turf/distance handles geographic calculations for you and returns accurate results in different units, so you don’t need to implement the formula manually.

import distance from '@turf/distance';

const from = [lon1, lat1];
const to = [lon2, lat2];

const dist = distance(from, to, { units: 'meters' });

Option 3: Using Geoapify Geometry API

You can also calculate distances using the Geoapify Geometry Operations API.

This API lets you calculate distances between geometries — including points, lines, and polygons — without implementing the logic yourself.

Example request:

POST https://api.geoapify.com/v1/geometry/operation?apiKey=YOUR_API_KEY

{
  "operation": "distance",
  "point1": {"type": "Point", "coordinates": [lon1, lat1]},
  "point2": {"type": "Point", "coordinates": [lon2, lat2]},
  "params": {
    "units": "kilometers"
  }
}

This approach is useful when you want:

server-side calculations
consistent results across services
support for complex geometries (not just points)

It can also be integrated into AI agents or automated workflows, where distance calculations are part of a larger decision-making process (for example, validating locations or triggering actions based on proximity).

Code Sample: Try It on a Map

Seeing this in action makes the behavior much easier to understand.

Try clicking on different locations in this interactive demo:

👉 CodePen demo / code sample

What to test:

Click directly on a building
Click on a road
Click inside a park or open area
Click near building edges or entrances

You’ll notice that:

the returned address doesn’t always match the exact clicked point
the marker may appear slightly shifted
results depend on nearby addressable objects

This makes it easier to see how reverse geocoding behaves in real-world scenarios.

How to Handle This in Your App

To avoid confusion when working with reverse geocoding:

Don’t expect exact matches — results are approximate
Show both clicked and returned locations if needed
Use distance thresholds for validation
Prefer geometry checks (e.g., inside building) for higher accuracy
Communicate clearly that the address is the nearest one

These small adjustments can significantly improve user experience.

Is There a Free UK Postcode Lookup API?

Alfiya Tarasenko — Sat, 11 Apr 2026 21:42:33 +0000

At first glance, the answer seems like yes. There are several APIs that let you search postcodes and return location or address data — for example, the Geoapify Postcode API.

But if you try a few of them, you’ll notice something: results can differ. Some APIs return more complete data, others return partial results — or nothing at all for the same postcode.

Even well-known providers can be inconsistent. The reason isn’t the API. It’s the data.

In the UK, the most complete postcode and address dataset is owned by Royal Mail and distributed under license. Free alternatives exist, but they are never fully complete or fully up to date.

What is a postcode in the UK?

UK postcodes are part of the addressing system used by Royal Mail.

In practice, postcodes are linked to specific geographic points where real addresses are grouped. Each postcode represents a set of properties assigned to that location.

Unlike unique identifiers, a single postcode usually corresponds to multiple addresses — sometimes just a few buildings, sometimes dozens.

Example of postcode locations in London. Each point represents a postcode linked to a group of addresses. Source: ONS Postcode Directory (Live)

Postcodes were designed for mail delivery, not precise mapping. That’s why they are often represented as points (centroids) rather than exact building locations.

⚠️ Even when postcode locations are available, it’s not always clear which postcode a specific building belongs to. A postcode represents a group of addresses, not a single precise location.

Who owns UK postcode data?

The most complete postcode and address dataset in the UK is maintained by Royal Mail as part of the Postcode Address File (PAF). It contains the full mapping between postcodes and individual addresses.

However, it is not open data.

Access to Royal Mail data is licensed, which means it cannot be freely used, shared, or redistributed. Most developers don’t access it directly, but through official distributors and resellers such as Ideal Postcodes, Postcoder, or Loqate.

This creates several practical challenges:

Higher cost compared to open alternatives
Licensing restrictions (storage, caching, redistribution)
Limited flexibility for building public or large-scale services

As a result, this data is often unavailable to developers who need free, open, or permissively licensed solutions — forcing them to rely on alternative datasets.

Are there free UK postcode lookup solutions?

Yes — there are several free and open solutions available. However, they differ in coverage, structure, and use cases.

Open data sources

Here are the main open datasets used for UK postcode lookup:

Name	Link	Description
ONS Postcode Directory (ONSPD)	Dataset link	The most complete open dataset. Provides postcode coordinates and administrative areas, but no full addresses.
GeoNames	Dataset link	Global dataset with partial UK postcode coverage. Simpler and less detailed.
OpenStreetMap	Website	Crowdsourced dataset where postcodes are often assigned directly to buildings or areas. Coverage and accuracy vary.

These datasets are free and open, but they do not provide full postcode → address mapping.

Postcode lookup APIs based on open data

To make these datasets easier to use, you can rely on APIs built on top of open data.

One example is the Geoapify Postcode API.

It allows you to:

Search by postcode
Get coordinates and address information
Use a simple HTTP API

Geoapify combines multiple open data sources (such as OpenStreetMap and GeoNames) to provide practical postcode lookup functionality.

Here’s a request example:

curl "https://api.geoapify.com/v1/postcode/search?postcode=TW2%207LS&countrycode=gb&geometry=original&apiKey=YOUR_API_KEY"

And response example:

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": {
        "postcode": "TW2 7LS",
        "lon": -0.3583,
        "lat": 51.4513,
        "datasource": {
          "sourcename": "geonames",
          "attribution": "GeoNames",
          "license": "CC BY 4.0",
          "url": "https://www.geonames.org/datasources/"
        },
        "country": "United Kingdom",
        "country_code": "gb",
        "state": "England",
        "city": "Greater London",
        "district": "London Borough of Richmond upon Thames",
        "formatted": "London, TW2 7LS, United Kingdom"
      },
      "geometry": {
        "type": "Point",
        "coordinates": [-0.3583, 51.4513]
      }
    }
  ]
}

⚠️ Results are based on open data sources and may differ from official Royal Mail data.

Free vs Official UK Postcode Data: Which One to Use?

The right choice depends on your use case and requirements.

Comparison

	Proprietary data (Royal Mail PAF)	Open data solutions
Coverage	Most complete	High but incomplete
Addresses	Full address list	Limited or none
Accuracy	Highest	Good, but varies
Cost	Paid	Free
Licensing	Restricted	Open / permissive
Best for	Validation, delivery, checkout	Maps, search, analytics

When to use proprietary data

Use Royal Mail-based solutions (via licensed providers) if you need:

Accurate address validation
Checkout or form autofill
Delivery and logistics systems
Guaranteed coverage

When to use open solutions

Use open data and APIs (like Geoapify) if you need:

Postcode → location lookup
Mapping and visualization
General search functionality
Free or open-source-friendly solutions

Conclusion

So, is there a free UK postcode lookup API?

Yes — but with limitations.

Free and open solutions can work well for many use cases, especially for mapping, search, and general applications. But they rely on datasets that are not fully complete.

If you need accurate, address-level data, you’ll need access to Royal Mail’s licensed dataset.

In the end, UK postcode accuracy is not a technical problem — it’s a data ownership problem.

If you want to try a free solution yourself, explore the Geoapify Postcode API Playground and test postcode lookup in practice.

Google Maps isn’t your only option for place search 👀 I compared 5 Places APIs (Google, Geoapify, Foursquare, HERE, TomTom) with real examples, pricing, and trade-offs

Alfiya Tarasenko — Wed, 08 Apr 2026 12:38:40 +0000

Alfiya Tarasenko for Geoapify Maps API

Apr 8

Google Places API Alternatives: Which POI API Should You Use in 2026?

#webdev #javascript #api #programming

11 min read

Google Places API Alternatives: Which POI API Should You Use in 2026?

Alfiya Tarasenko — Wed, 08 Apr 2026 12:37:13 +0000

If your app needs to search for places — cafes, restaurants, shops, or any other points of interest — chances are you’ve looked at the Google Maps Platform first.

It’s a powerful solution, but it’s not always the best fit. Pricing, usage limits, licensing restrictions, or simply the need for more flexibility often push developers to look for alternatives.

What we’ll explore

In this article, we’ll take a practical look at Places APIs — focusing on one common use case:

Finding places by category. For example: cafes or restaurants near a location

We’ll compare how place search works across several popular providers and when each one makes the most sense to use:

Google Maps Platform — Places API
Geoapify — Places API
Foursquare — Places API
HERE Technologies — Geocoding & Search API
TomTom — Search API (POI search)
What to choose?

Use Case: Find Restaurants in Miami Beach

To keep this comparison practical, let’s use one specific scenario:

Find restaurants near this point in Miami Beach:

Latitude: 25.777415
Longitude: -80.132432

This is a good test case because every provider in this article supports location-based place search, but they expose it in different ways.

Key differences to keep in mind

Request structure: Some APIs use simple query parameters (location, radius, category), while others require more structured requests or additional configuration.
Search capabilities: APIs vary in how they support filtering, ranking, and biasing results.
Data sources: Some providers rely on proprietary datasets, while others are based on open data sources like OpenStreetMap.
Result format: The structure and level of detail in responses can differ significantly.

Even for a simple task like finding nearby restaurants, the choice of API can lead to very different results and developer experience.

Google Maps Platform — Places API

📘 Docs · 🔎 Playground · 💰 Pricing · ⚖️ Terms

The Google Maps Platform Places API is one of the most widely used solutions for working with points of interest.

It provides rich and detailed place data — including ratings, reviews, opening hours, and more — and is often the default choice for developers building location-based features.

Example request

POST https://places.googleapis.com/v1/places:searchNearby
Content-Type: application/json
X-Goog-Api-Key: YOUR_API_KEY
X-Goog-FieldMask: places.displayName,places.location,places.rating,places.reviews,places.photos

{
  "includedPrimaryTypes": ["restaurant"],
  "maxResultCount": 10,
  "locationRestriction": {
    "circle": {
      "center": {
        "latitude": 25.777415,
        "longitude": -80.132432
      },
      "radius": 1000
    }
  }
}

This request searches for restaurants near the given coordinates in Miami Beach within a 1 km radius and returns a limited set of fields.

Example response

{
  "places": [
    {
      "id": "sample-place-id-001",
      "displayName": {
        "text": "Sample Restaurant"
      },
      "formattedAddress": "100 Example St, Miami Beach, FL 33139, USA",
      "location": {
        "latitude": 25.778102,
        "longitude": -80.131245
      },
      "rating": 4.4,
      "userRatingCount": 1842,
      "websiteUri": "https://www.example.com",
      "nationalPhoneNumber": "(305) 555-0142",
      "regularOpeningHours": {
        "openNow": true,
        "weekdayDescriptions": [
          "Monday: 11:00 AM – 10:00 PM"
        ]
      },
      "primaryType": "restaurant",
      "primaryTypeDisplayName": {
        "text": "Restaurant"
      }
    }
  ]
}

The response can include much more than basic place information. In addition to name, location, and rating, the API can return reviews, photos, contact details, opening hours, and various attributes describing the place.

Reviews are returned directly in the response, while photos are provided as references that can be used to request actual images via a separate endpoint.

The exact data you receive depends on the fields specified in the X-Goog-FieldMask.

Pros

Rich place data — includes ratings, reviews, photos, opening hours, and many additional attributes
Flexible field selection — control response size and content via X-Goog-FieldMask
Large dataset — backed by a widely used platform with high user contribution and coverage

Cons

Pricing can scale quickly — depends on number of requests and fields requested, so cost estimation is important
Strict licensing terms — usage is limited by Google Maps Platform Terms, including requirements on how data is displayed, where it can be used, and integration with Google services
Data usage limitations — place data often cannot be stored long-term or used outside Google services
More complex requests — requires POST requests and field masks instead of simple query parameters

Geoapify — Places API

📘 Docs · 🔎 Playground · 💰 Pricing · ⚖️ Terms

Geoapify Places API provides access to POI data based on open data sources such as OpenStreetMap.

It focuses on simplicity and flexibility, offering a straightforward way to search for places by category, location, and additional filters.

Example request

GET https://api.geoapify.com/v2/places?categories=catering.restaurant&filter=circle:-80.132432,25.777415,1000&limit=10&apiKey=YOUR_API_KEY

This request searches for restaurants near the given coordinates in Miami Beach within a 1 km radius.

The API uses a simple GET request with query parameters, making it easy to test and integrate.

Example response

{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": {
        "name": "Bella Cuba",
        "formatted": "Bella Cuba, 1659 Washington Avenue, Miami Beach, FL 33139, United States of America",
        "lat": 25.7909549,
        "lon": -80.1316981,
        "categories": [
          "catering",
          "catering.restaurant",
          "catering.restaurant.cuban"
        ],
        "catering": {
          "cuisine": "cuban"
        },
        "distance": 265,
        "datasource": {
          "sourcename": "openstreetmap",
          "license": "Open Database License",
          "attribution": "© OpenStreetMap contributors"
        },
        "raw": {
            "osm_id": 3057276069,
            "osm_type": "n"
          }
      },
      "geometry": {
        "type": "Point",
        "coordinates": [-80.1316981, 25.7909549]
      }
    }
  ]
}

The response uses a standard GeoJSON-like structure, which is especially convenient for map applications. Depending on available source data, results may include categories, cuisine, phone number, website, opening hours, and other attributes.

The datasource field is especially useful because it makes the data origin explicit. In this example, the results come from OpenStreetMap, with attribution and license information included in the response.

The raw.osm_id and raw.osm_type values allow you to link back to the original OpenStreetMap object — for example: view this place in OpenStreetMap >>

Pros

Open data (OpenStreetMap-based) — transparent data source that allows you to cache, store, and redistribute data, depending on the OpenStreetMap license terms
Affordable pricing model — as a service provider (not a data owner), Geoapify offers more cost-efficient and predictable pricing
Simple and intuitive API — uses GET requests with clear query parameters, making it easy to test and integrate
Flexible usage — not tightly coupled to a specific platform, allowing more freedom in how data is stored and displayed
GeoJSON-like response format — ready to use directly in mapping libraries without transformation

Cons

No built-in reviews or ratings — unlike Google, the API does not provide user-generated reviews, ratings, or photos
Data completeness varies — coverage and quality depend on OpenStreetMap data in the region
Less enriched data — fewer high-level attributes compared to Google’s dataset
May require additional data sources — some features (e.g. reviews or popularity) may require integration with other APIs

Foursquare — Places API

📘 Docs · 💰 Pricing · ⚖️ Terms

Foursquare Places API provides access to a global POI dataset enriched with location intelligence and user behavior signals.

It is known for its structured place data and strong categorization system, making it well-suited for search and discovery use cases.

curl --request GET \
     --url 'https://api.foursquare.com/v3/places/search?ll=25.777415%2C-80.132432&radius=1000&categories=restaurants' \
     --header 'X-Places-Api-Version: 2023-10-01' \
     --header 'accept: application/json'

This request searches for restaurants near the given coordinates in Miami Beach within a 1 km radius.

Foursquare uses category IDs instead of text-based categories, which allows precise filtering but requires referencing their category taxonomy.

Example response

{
  "results": [
    {
      "fsq_id": "5f8a9c1b2d_example",
      "name": "Ocean Breeze Grill",
      "location": {
        "formatted_address": "200 Ocean Dr, Miami Beach, FL 33139",
        "locality": "Miami Beach",
        "region": "FL",
        "country": "US"
      },
      "geocodes": {
        "main": {
          "latitude": 25.778245,
          "longitude": -80.130912
        }
      },
      "categories": [
        {
          "id": 13065,
          "name": "Restaurant",
          "short_name": "Restaurant"
        }
      ],
      "distance": 180,
      "rating": 4.3,
      "price": 2,
      "tel": "+1 305-555-0199",
      "website": "https://oceanbreeze.example.com",

      "hours": {
        "display": "Mon–Sun 11:00 AM – 11:00 PM",
        "open_now": true
      },

      "features": {
        "services": {
          "delivery": true,
          "takeout": true,
          "dine_in": {
            "reservations": true
          }
        },
        "food_and_drink": {
          "meals": {
            "lunch": true,
            "dinner": true
          },
          "alcohol": {
            "beer": true,
            "wine": true
          }
        },
        "amenities": {
          "outdoor_seating": true,
          "wifi": "free"
        }
      },

      "photos": [
        {
          "id": "photo_001",
          "prefix": "https://fastly.4sqi.net/img/general/",
          "suffix": "/12345_sample.jpg",
          "width": 800,
          "height": 600
        }
      ],

      "tips": [
        {
          "id": "tip_001",
          "text": "Great seafood and ocean views. Try the grilled snapper!",
          "agree_count": 12
        }
      ],

      "stats": {
        "total_ratings": 540,
        "total_photos": 120,
        "total_tips": 34
      },

      "popularity": 0.82,
      "verified": true
    }
  ],
  "context": {
    "geo_bounds": {
      "circle": {
        "center": {
          "latitude": 25.777415,
          "longitude": -80.132432
        },
        "radius": 1000
      }
    }
  }
}

The response includes core place information such as name, location, categories, and distance. Depending on the endpoint and plan, Foursquare can also provide additional enrichment such as ratings, popularity signals, and place attributes.

Pros

Rich and structured place data — includes categories, attributes, popularity signals, and user-generated content
Includes user-generated content — provides photos and tips, adding useful context to places, though the coverage and depth may vary compared to larger platforms like Google Maps Platform
Strong categorization system — enables precise filtering using a well-defined taxonomy (category IDs)
High-quality curated dataset — especially strong in urban areas and commercial locations
Enriched data signals — provides popularity, trends, and behavioral insights beyond basic POI data

Cons

Strict licensing restrictions — data is provided under a limited, revocable license and must be used only within your application; you cannot store, merge, redistribute, or build your own POI dataset, and must display “Powered by Foursquare” attribution
Limited external usage — reports or demos must be non-monetized, non-competitive, and cannot expose material portions of data
Category-based filtering complexity — requires working with category IDs instead of simple text queries
Pricing scales with usage — costs can increase with request volume and data enrichment

HERE Technologies — Places API

📘 Docs · 🔎 Playground · 💰 Pricing · ⚖️ Terms

HERE Technologies provides location services and POI data through its Discover endpoint, which allows searching for places by category, location, and filters.

It is widely used in navigation, mobility, and enterprise applications, especially where accurate geolocation is critical.

Example request

GET https://discover.search.hereapi.com/v1/discover?at=25.777415,-80.132432&q=restaurant&limit=10&apiKey=YOUR_API_KEY

This request searches for restaurants near the given coordinates in Miami Beach.

Example response

{
  "items": [
    {
      "id": "here-poi-001",
      "title": "Ocean Breeze Restaurant",
      "resultType": "place",

      "address": {
        "label": "150 Ocean Dr, Miami Beach, FL 33139, United States",
        "countryCode": "USA",
        "countryName": "United States",
        "stateCode": "FL",
        "state": "Florida",
        "city": "Miami Beach",
        "street": "Ocean Dr",
        "postalCode": "33139",
        "houseNumber": "150"
      },

      "position": {
        "lat": 25.778215,
        "lng": -80.131102
      },

      "distance": 210,

      "categories": [
        {
          "id": "100-1000-0000",
          "name": "Restaurant",
          "primary": true
        }
      ],

      "foodTypes": [
        {
          "id": "101-000",
          "name": "Seafood",
          "primary": true
        }
      ],

      "contacts": [
        {
          "phone": [
            {
              "value": "+1 305-555-0188"
            }
          ],
          "www": [
            {
              "value": "https://oceanbreeze.example.com"
            }
          ]
        }
      ],

      "openingHours": [
        {
          "text": [
            "Mon–Sun: 11:00 AM – 11:00 PM"
          ],
          "isOpen": true
        }
      ],

      "timeZone": {
        "name": "America/New_York",
        "utcOffset": "-04:00"
      },

      "chains": [
        {
          "id": "chain-001",
          "name": "Ocean Breeze Group"
        }
      ],

      "media": {
        "images": {
          "items": [
            {
              "href": "https://images.example.com/photo1.jpg",
              "supplier": {
                "id": "tripadvisor"
              }
            }
          ]
        },
        "ratings": {
          "items": [
            {
              "count": 320,
              "average": 4.2,
              "supplier": {
                "id": "tripadvisor"
              }
            }
          ]
        }
      }
    }
  ],
  "count": 1,
  "limit": 10,
  "offset": 0
}

The HERE API returns structured place data with a strong focus on address details, categories, and consistency across regions.

Depending on the available data, the response may include:

Contact details such as phone numbers and websites
Opening hours in both structured and human-readable formats
Categories and food types for classification
Media and ratings, often sourced from third-party providers (for example, TripAdvisor)
Extended attributes such as EV charging stations, fuel information, or logistics-related data

Compared to consumer-focused APIs, HERE emphasizes reliable, standardized data and global coverage rather than building its own user-generated content ecosystem.

Pros

Reliable global coverage — strong presence across multiple regions and industries, including automotive and logistics
Structured and consistent data — predictable response format with detailed address components and classification
Simple request model — supports text-based and location-based search without complex request bodies
Enterprise-focused features — includes extended attributes such as EV stations, fuel data, and logistics-related information
Third-party enrichment — may include ratings and media from external providers (for example, TripAdvisor)

Cons

Proprietary dataset — data is not open and cannot be freely stored, reused, or redistributed
Limited user-generated content — generally does not provide native reviews or rich photo ecosystems like larger consumer platforms
Licensing restrictions — usage is governed by HERE terms, including limitations on storage, redistribution, and usage scope
Pricing scales with usage — costs depend on request volume and service usage

TomTom — Places API

📘 Docs · 🔎 Playground · 💰 Pricing · ⚖️ Terms

TomTom provides access to place data through its Search and Places APIs, allowing developers to search for POIs by category, name, or geographic location.

It is widely used in navigation, mobility, and enterprise applications, with a focus on accurate geolocation and global coverage.

Example request

curl -X GET "https://api.tomtom.com/search/2/categorySearch/restaurants.json?lat=25.777415&lon=-80.132432&radius=1000&categorySet=7315&view=Unified&relatedPois=off&key=YOUR_API_KEY" \
  -H "accept: */*"

This request searches for restaurants within a 1 km radius around Miami Beach and returns categorized place results using TomTom’s Places API.

Example response

{
  "summary": {
    "query": "restaurants",
    "queryType": "NON_NEAR",
    "numResults": 10,
    "offset": 0,
    "totalResults": 84,
    "geoBias": {
      "lat": 25.777415,
      "lon": -80.132432
    }
  },
  "results": [
    {
      "type": "POI",
      "id": "tomtom-poi-001",
      "score": 2.57,
      "dist": 145.3,
      "poi": {
        "name": "Ocean Breeze Cafe",
        "phone": "+1 305-555-0181",
        "url": "www.oceanbreeze.example.com",
        "categorySet": [
          {
            "id": 7315
          }
        ],
        "categories": [
          "restaurant"
        ],
        "classifications": [
          {
            "code": "RESTAURANT",
            "names": [
              {
                "nameLocale": "en-US",
                "name": "restaurant"
              }
            ]
          }
        ]
      },
      "address": {
        "streetNumber": "120",
        "streetName": "Ocean Dr",
        "municipality": "Miami Beach",
        "countrySubdivision": "FL",
        "postalCode": "33139",
        "countryCode": "US",
        "country": "United States",
        "freeformAddress": "120 Ocean Dr, Miami Beach, FL 33139"
      },
      "position": {
        "lat": 25.778201,
        "lon": -80.131502
      },
      "entryPoints": [
        {
          "type": "main",
          "position": {
            "lat": 25.77812,
            "lon": -80.13144
          }
        }
      ]
    },
    {
      "type": "POI",
      "id": "tomtom-poi-002",
      "score": 2.56,
      "dist": 210.8,
      "poi": {
        "name": "Seaside Grill",
        "categorySet": [
          {
            "id": 7315
          }
        ],
        "categories": [
          "restaurant"
        ]
      },
      "address": {
        "freeformAddress": "200 Collins Ave, Miami Beach, FL 33139"
      },
      "position": {
        "lat": 25.77901,
        "lon": -80.13088
      }
    }
  ]
}

The response includes a summary section plus a list of matching POIs. For each result, TomTom returns core place information such as the place name, categories, address, coordinates, and distance. Some results may also include contact details like a phone number or website.

A useful detail is the entryPoints field, which can help in routing and navigation scenarios by showing where the place can actually be accessed.

Pros

Reliable global location data — strong coverage optimized for navigation and mobility use cases
Well integrated with routing services — works seamlessly with routing, traffic, and navigation APIs
Simple and developer-friendly API — clear parameters and predictable responses
Accurate positioning data — includes fields like entryPoints for real-world navigation

Cons

Limited focus on user-generated content — minimal support for reviews or community-driven insights
Limited media support — photos and rich media are not part of standard responses
Proprietary dataset — data cannot be freely stored or redistributed
Licensing restrictions — usage is constrained by TomTom terms and conditions

What to choose?

Choosing a Places API depends not only on features, but also on your use case, constraints, and budget. Here’s a practical way to approach it.

1. Define your goal

Start with what you actually need to build:

Rich place details (reviews, photos, popularity signals) → Best fit: Google Maps Platform, Foursquare, HERE
Category-based search with structured place data (no need for reviews) → Best fit: Geoapify, TomTom, HERE
Navigation, routing, fleet, or logistics applications

→ Best fit: TomTom, HERE, Geoapify

👉 If your app relies on user-generated content, your main options are Google or Foursquare.

2. Consider your budget early

Pricing models differ significantly:

Google Maps Platform → powerful but can scale in cost quickly
Foursquare → commercial dataset with flexible plans
HERE / TomTom → enterprise-oriented pricing, often bundled with other services
Geoapify → affordable and predictable pricing

👉 Always estimate usage before building — especially for high-traffic apps.

3. Check licensing and data restrictions

This is often a deciding factor:

Some providers restrict storing or caching data (e.g., Google)
Some allow more flexibility with usage and storage
Most require attribution

👉 If you need to store or reuse data, this can narrow your options quickly.

4. Match provider strengths

Each provider is optimized for different scenarios:

Google / Foursquare → rich place content and discovery
HERE / TomTom → navigation, routing, and enterprise mobility
Geoapify → flexible APIs with open-data foundation, providing access to OpenStreetMap (OSM) data

👉 Example:

Building a city discovery app → Foursquare or Geoapify
Building a delivery platform → HERE or TomTom
Building an infrastructure or utility app (electricity, supply, field services) → Geoapify, TomTom, or HERE

5. Think long-term

Switching providers later can be costly.

Consider:

scaling costs
API limits
vendor lock-in
data portability

Summary

There is no single “best” API — only the best fit for your case.

Choose Google or Foursquare for rich place content
Choose HERE or TomTom for routing and mobility
Choose Geoapify for flexibility, open data, and cost efficiency

👉 The right choice comes down to balancing features, budget, and licensing constraints.