Geoapify SDKs & Libraries: Official & Community Tools (2026)

SDKs overview

Geoapify offers Software Development Kits (SDKs) and libraries to facilitate the integration of its geospatial services into various applications. These SDKs provide a layer of abstraction over direct HTTP API calls, simplifying common development tasks related to maps, geocoding, routing, and place search. By using an SDK, developers can interact with Geoapify's APIs through language-specific objects and functions, which can reduce development time and improve code maintainability.

The primary focus of Geoapify's official SDK development has been on JavaScript, reflecting its widespread use in web-based mapping applications. These SDKs are designed to work seamlessly with front-end frameworks and provide components for rendering interactive maps and handling user interactions. The Geoapify documentation provides comprehensive guides and examples for setting up and utilizing these tools, ensuring developers have the necessary resources for successful implementation. For a detailed understanding of supported APIs, the Geoapify APIs reference offers further information.

Beyond the official offerings, the open-source nature of web development and Geoapify's publicly available APIs encourage the creation of community-contributed libraries. These community efforts often extend support to other programming languages or integrate Geoapify services into specific frameworks not directly covered by official SDKs. While official SDKs are maintained by Geoapify, community libraries rely on volunteer contributions and may vary in their level of support and feature completeness.

Official SDKs by language

Geoapify's official SDK development is primarily concentrated on JavaScript, providing robust tools for web and client-side applications. These SDKs offer direct interfaces to Geoapify's core products, including the Geocoding API, Places API, Routing API, and Map Tiles API. The JavaScript SDKs are designed to integrate with modern web development workflows, supporting both module-based and script-tag inclusions.

The main JavaScript SDK provides functionalities for:

• Map Initialization and Display: Tools to embed interactive maps into web pages, allowing customization of map styles, layers, and controls. This includes support for various map projections and tile sources.
• Geocoding and Reverse Geocoding: Methods to convert addresses to coordinates and vice versa, often including autocomplete features for user input.
• Place Search and Details: Functions to search for points of interest (POIs) by category, name, or location, and retrieve detailed information about selected places.
• Routing and Navigation: Capabilities to calculate routes between multiple points, considering different transportation modes and constraints like traffic or road types.

While JavaScript is the primary language for official SDKs, Geoapify provides extensive API reference documentation with examples in multiple languages, including Python, PHP, and cURL, to assist developers in making direct API calls from various backend environments. This approach ensures that developers using server-side languages can still integrate Geoapify services effectively, even without a dedicated server-side SDK.

Here is a summary of the official SDKs:

Installation

Installing Geoapify's JavaScript SDKs typically involves using a package manager like npm or yarn, or by including the library directly via a CDN link in your HTML. The specific method depends on your project setup and whether you are using a module bundler such as Webpack or Rollup.

Using npm (Node Package Manager)

For modern JavaScript projects, npm is the recommended way to install Geoapify packages. This allows for easier dependency management and integration with build tools. To install a specific Geoapify package, open your terminal in your project directory and run:

npm install @geoapify/geocoder-autocomplete

This command downloads the @geoapify/geocoder-autocomplete package and its dependencies into your node_modules directory, and adds it to your package.json file. You can then import it into your JavaScript files.

Using yarn

If your project uses yarn as its package manager, the installation command is similar:

yarn add @geoapify/geocoder-autocomplete

This achieves the same result as the npm command, installing the package and updating your yarn.lock file.

Via CDN (Content Delivery Network)

For simpler projects or quick prototyping, you can include Geoapify libraries directly in your HTML using a <script> tag pointing to a CDN. This method does not require a build step or package manager. The Geoapify Autocomplete documentation provides CDN links for their components.

<script src="https://cdn.geoapify.com/geoapify-geocoder-autocomplete.js"></script>

When using a CDN, the library's functions and objects are typically exposed globally (e.g., window.Geoapify), making them accessible directly in your scripts.

Quickstart example

This quickstart example demonstrates how to integrate the Geoapify Geocoder Autocomplete component into a web page using JavaScript. This component provides an input field with address suggestions as the user types, leveraging the Geoapify Geocoding API.

First, ensure you have an API key from Geoapify. You can obtain one by registering on the Geoapify pricing page, which includes a free tier for initial development.

HTML Structure

Create an HTML file (e.g., index.html) and include a <div> element that will host the autocomplete input. Also, link the necessary CSS and JavaScript files for the component, either from a CDN or your local node modules.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Geoapify Autocomplete Quickstart</title>
    <link rel="stylesheet" href="https://cdn.geoapify.com/geoapify-geocoder-autocomplete.css">
    <style>
        body { font-family: sans-serif; margin: 20px; }
        #autocomplete-container { width: 400px; margin-top: 20px; }
    </style>
</head>
<body>
    <h1>Geoapify Geocoder Autocomplete</h1>
    <div id="autocomplete-container"></div>
    
    <script src="https://cdn.geoapify.com/geoapify-geocoder-autocomplete.js"></script>
    <script>
        // Your JavaScript code will go here
    </script>
</body>
</html>

JavaScript Initialization

Inside the <script> tags, initialize the autocomplete component using your Geoapify API key. This example assumes you are using the CDN version, where GeoapifyGeocoderAutocomplete is globally available.

document.addEventListener('DOMContentLoaded', function() {
    const API_KEY = 'YOUR_GEOAPIFY_API_KEY'; // Replace with your actual API key

    const geocoderAutocomplete = new GeoapifyGeocoderAutocomplete(
        document.getElementById('autocomplete-container'),
        API_KEY,
        {
            /* Optional: customize options */
            // type: 'address',
            // limit: 5,
            // lang: 'en'
        }
    );

    geocoderAutocomplete.on('select', (location) => {
        console.log('Selected location:', location);
        alert('Selected: ' + location.properties.formatted);
    });

    geocoderAutocomplete.on('suggestions', (suggestions) => {
        console.log('Suggestions:', suggestions);
    });

    // To demonstrate clearing the input programmatically
    // setTimeout(() => {
    //     geocoderAutocomplete.setPlace('');
    // }, 5000);
});

Replace 'YOUR_GEOAPIFY_API_KEY' with your actual Geoapify API key. This script initializes the autocomplete input within the 'autocomplete-container' div. When a user selects a suggestion, the 'select' event is triggered, logging the selected location object to the console and displaying an alert with the formatted address. The 'suggestions' event also logs the list of suggestions as they appear.

For more advanced configurations and event handling, refer to the Geoapify Geocoder Autocomplete component documentation.

Community libraries

While Geoapify provides official SDKs primarily for JavaScript, the open nature of its APIs encourages the development of community-contributed libraries. These libraries often extend Geoapify's reach into other programming languages or integrate its services with specific frameworks and platforms that are not officially supported by Geoapify's core SDKs.

Community libraries can offer several advantages:

• Broader Language Support: Developers working in languages like Python, C#, or Go might find libraries that wrap Geoapify's REST APIs into native client libraries. These wrappers typically handle HTTP requests, response parsing, and authentication, making it easier to consume Geoapify data in server-side applications.
• Framework-Specific Integrations: Some community projects might provide components or hooks for popular web frameworks (e.g., React, Vue, Angular) that streamline the integration of Geoapify maps or search functionalities within those ecosystems.
• Specialized Tools: Community efforts sometimes focus on niche use cases, such as geospatial analysis tools that combine Geoapify data with other libraries for data visualization or advanced processing.

It is important to note that community libraries are maintained by individual developers or groups and are not officially supported by Geoapify. Their quality, documentation, and ongoing maintenance can vary. Developers considering these options should evaluate the library's activity, issue tracker, and community support before integrating them into production systems. Checking the project's GitHub repository for recent commits, open issues, and pull requests can provide insight into its health and reliability. For example, a well-maintained project might follow standard HTTP status code practices for API error handling, which would be reflected in its client library.

To discover community-supported libraries, developers can typically search platforms like GitHub, npm, or PyPI for packages related to "Geoapify" or specific Geoapify APIs. The Geoapify comprehensive documentation serves as the ultimate source of truth for API specifications, which any community library must adhere to for proper functionality.