Rappi SDKs & Libraries: Integration Guides and Tools (2026)

SDKs overview

Rappi's API and associated SDKs are designed to facilitate integrations for businesses seeking to automate order processing, manage inventory, and provide real-time delivery updates within the Rappi ecosystem. These tools primarily support merchants, logistics partners, and developers building applications that interact with Rappi's platform for on-demand delivery services in Latin America.

The core functionality exposed through Rappi's developer resources includes endpoints for managing orders from placement to fulfillment, maintaining synchronized product catalogs, and retrieving granular delivery status information. This allows partners to integrate Rappi's services directly into existing e-commerce platforms, point-of-sale systems, or custom logistics software, minimizing manual intervention and enhancing operational efficiency. For detailed information on the API structure and available endpoints, developers can consult the official Rappi API documentation.

Integration typically involves a formal partnership agreement with Rappi, which grants access to the necessary API keys and development resources. This structured approach ensures that integrations are aligned with Rappi's operational standards and security protocols, including compliance with regulations such as GDPR data protection principles, as noted in Rappi's compliance statements. The developer experience is centered on providing clear documentation for common integration patterns, such as fetching menu items, submitting new orders, and updating order states.

Official SDKs by language

As of 2026, Rappi primarily provides comprehensive API documentation and examples for direct HTTP requests, rather than maintaining a suite of official, language-specific client SDKs. This approach allows developers to use any programming language or framework capable of making HTTP requests to interact with the Rappi API. This method is common for RESTful APIs, where the API design itself serves as the primary interface definition, often complemented by tools like OpenAPI specifications.

While Rappi's direct support for client libraries is limited, the API is well-documented, enabling developers to generate SDKs using OpenAPI Generator or similar tools, or to write custom client code. The focus remains on clear API specifications to ensure broad compatibility across different development environments.

The following table outlines common approaches and typical SDK-like components developers might use when integrating with Rappi:

Installation

Since Rappi emphasizes direct API interaction over pre-built SDKs, installation primarily involves setting up an HTTP client library in your chosen programming language. These libraries handle the complexities of making web requests, managing headers, and parsing responses, forming the foundation for your custom Rappi API client.

Python

For Python, the requests library is a widely used choice for making HTTP requests:

pip install requests

Once installed, you can import it into your Python scripts to start sending requests to the Rappi API. The requests library simplifies common tasks like setting authentication headers, handling JSON payloads, and managing various HTTP methods (GET, POST, PUT, DELETE).

Node.js

In Node.js environments, axios is a popular promise-based HTTP client. Alternatively, the native node-fetch module provides a browser-compatible Fetch API implementation.

npm install axios

Or for node-fetch:

npm install node-fetch

These packages integrate smoothly into modern JavaScript development workflows, supporting asynchronous operations and structured error handling, which are crucial for reliable API interactions. Developers using Node.js can leverage the extensive ecosystem of npm packages to build robust integrations.

Java

Java developers can use the built-in java.net.http.HttpClient (available since Java 11) or third-party libraries like OkHttp or Apache HttpClient. For Maven-based projects, add the dependency:

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.9.3</version>
</dependency>

Or for Gradle:

implementation 'com.squareup.okhttp3:okhttp:4.9.3'

Java's strong typing and robust exception handling make it suitable for enterprise-grade integrations, ensuring data integrity and reliable communication with external services like Rappi.

PHP

For PHP projects, Guzzle is a widely adopted HTTP client. Install it via Composer:

composer require guzzlehttp/guzzle

Guzzle provides a flexible interface for making HTTP requests, supporting various request methods, handling redirects, and managing cookies, which are essential for interacting with diverse API specifications. PHP's widespread use in web development makes Guzzle a practical choice for Rappi integrations within web applications.

Quickstart example

This quickstart demonstrates fetching a list of available stores using the Rappi API in Python. You will need an API key and a partner ID, which are obtained through a Rappi partnership agreement. Replace placeholders with your actual credentials.

Python example: Fetching Stores

This example uses the requests library to make a GET request to a hypothetical Rappi endpoint for stores. The Rappi API documentation provides specific endpoints for merchant integration tasks like catalog management and order processing.

import requests
import json

# Replace with your actual Rappi API Key and Partner ID
RAPPI_API_KEY = "YOUR_RAPPI_API_KEY"
RAPPI_PARTNER_ID = "YOUR_RAPPI_PARTNER_ID"

# Base URL for Rappi Partner API (this is a placeholder, refer to Rappi docs for actual endpoint)
BASE_URL = "https://api.rappi.com/v3/"

def get_available_stores(latitude, longitude):
    headers = {
        "Authorization": f"Bearer {RAPPI_API_KEY}",
        "X-Rappi-Partner-Id": RAPPI_PARTNER_ID,
        "Content-Type": "application/json"
    }
    params = {
        "lat": latitude,
        "lng": longitude,
        "country_code": "CO" # Example: Colombia
    }
    
    # This endpoint is illustrative; refer to Rappi's official API reference for correct paths
    endpoint = f"{BASE_URL}stores"
    
    try:
        response = requests.get(endpoint, headers=headers, params=params)
        response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
        stores_data = response.json()
        return stores_data
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err} - {response.text}")
    except Exception as err:
        print(f"An error occurred: {err}")
    return None

if __name__ == "__main__":
    # Example coordinates for a location in Colombia
    example_latitude = 4.7110
    example_longitude = -74.0721
    
    stores = get_available_stores(example_latitude, example_longitude)
    
    if stores:
        print("Successfully fetched stores:")
        print(json.dumps(stores, indent=2))
        # Process the stores data, e.g., display store names and categories
        for store in stores.get('data', []):
            print(f"  - {store.get('name')} (ID: {store.get('id')})")
    else:
        print("Failed to fetch stores.")

This example illustrates the fundamental pattern of authenticating with an API key, constructing a request with necessary parameters, and handling the JSON response. For actual endpoint details, parameter requirements, and response structures, always consult the Rappi official API documentation.

Community libraries

Given Rappi's strategic focus on direct API integration with comprehensive documentation, the landscape of community-contributed SDKs and libraries is less developed compared to platforms that actively release and maintain SDKs for multiple programming languages. Developers typically create custom clients or leverage general-purpose HTTP libraries in their preferred languages to interact with the Rappi API.

While a formal registry of community-maintained Rappi SDKs is not prominently featured, developers often share code snippets, utility functions, and integration examples within developer forums, GitHub repositories, or technical blogs. These community efforts often address specific integration challenges, such as:

• Webhook handling: Libraries or frameworks to parse and validate incoming webhook notifications from Rappi, signaling order updates or status changes.
• Authentication helpers: Functions or classes to manage API key rotation, signature generation (if applicable), and secure credential storage.
• Data model mapping: Custom classes or data structures that mirror Rappi's API response objects, simplifying data access and reducing boilerplate code.
• Error handling utilities: Centralized mechanisms for interpreting Rappi API error codes and providing user-friendly messages or logging.

Developers seeking community support or examples are encouraged to search public code repositories like GitHub for projects tagged with 'Rappi API' or 'Rappi integration'. Participating in relevant developer communities or forums focused on e-commerce and logistics integrations can also provide insights into how other partners are successfully interacting with the Rappi platform. It is important to note that community-maintained libraries do not carry the same level of official support or guarantees as vendor-supplied SDKs and should be evaluated for security, maintenance, and compatibility before production use.