# Rappi API MCP > Rappi API MCP Server gives your agent direct control over Latin America’s largest super-app for deliveries and local commerce. Forget navigating a consumer mobile interface; this server connects to Rappi's core logistics endpoints, letting your AI client manage everything from order intake and real-time courier tracking to menu retrieval and support ticket creation. You can automatically take orders using `take_order`, check store stock with `get_store_availability`, or even dispute missing items via the agent. ## Overview - **Category:** industry-titans - **Price:** Free - **Tags:** delivery-services, hyper-local, logistics-tracking, courier-management, last-mile-delivery ## Description Forget trying to scrape Rappi's website or making your agent click through the consumer app like a human. This server gives your AI client direct access to the core logistics endpoints, letting you manage an entire order lifecycle for Latin America’s biggest super-app. You don't just process orders; you run the whole show. **Setting Up and Checking Store Operations** You gotta know what stores are even open before you take orders. Use `list_stores` to get a complete list of every operational account ID associated with your setup. Before running any workflow, check if a location is accepting business by calling `get_store_availability`; this immediately tells you if a store's status is active or closed. If the whole operation needs to pause—maybe for inventory counts or maintenance—you can control it right away using `update_store_status` to either open up or shut down a location completely. **Managing Menu and Inventory Data** Knowing what they sell is half the battle. For any store ID you've pulled from your list, run `get_store_menu` to pull the most current item catalog available for sale. This gives you the full picture of inventory without needing a manual check. When an order comes in, you can confirm that the items are actually stocked and available by checking the real-time status through `get_store_availability`. **Handling Incoming Order Flow** This is where your agent does the heavy lifting. First, to see what needs attention, run `list_new_orders`; this pulls a batch list of every incoming order that's sitting there waiting for staff acceptance. When you confirm an order is good to go, use `take_order` to officially accept it and kick off preparation. If the order isn't right—maybe the wrong items were requested or the store is closed—you can reject it immediately via `reject_order`, making sure you pass a specific reason in the payload. Once accepted, keep track of it using `get_order_detail` to pull every piece of information tied to a specific order ID. When the staff finishes prepping that food or package, you send a signal to the system by calling `mark_ready_for_pickup`, letting the courier know it's ready for them. If something goes wrong before pickup, you can still get the necessary codes to validate or finalize the handoff process using `get_order_handoff`. **Automating Core Logistics Workflows** This server lets your agent manage everything from listing all registered locations with `list_stores`, to ensuring a store is open enough to take orders via `get_store_availability`. You can maintain the full catalog using `get_store_menu` and, when it's time to execute, you control acceptance flows by taking an order with `take_order` or rejecting it immediately with `reject_order`. When prep is done, use `mark_ready_for_pickup`, then get all the data points you need for tracking with `get_order_detail`. You also keep the whole system running smoothly by setting store status using `update_store_status` when needed. It's built to handle the entire operational process without any manual intervention. ## Tools ### get_order_detail Retrieves all specific information about a single, existing order using its ID. ### get_order_handoff Gets the required confirmation codes needed to validate or finalize an order handoff process. ### get_store_availability Checks and reports the current operational status (open/closed) of a specific store location. ### get_store_menu Pulls the complete, up-to-date list of items available for sale at a given store ID. ### list_new_orders Retrieves a batch list of all incoming orders that are currently awaiting acceptance by staff. ### list_stores Lists every registered store location associated with your operational account ID. ### mark_ready_for_pickup Sends a signal to the system that an accepted order is physically prepared and ready for the courier. ### reject_order Declines an incoming order immediately, requiring you to provide a specific reason for rejection in the payload. ### take_order Accepts and officially starts preparation for a newly received incoming order ID. ### update_store_status Changes the operational status of an entire store—either opening it or closing it to prevent new orders. ## Prompt Examples **Prompt:** ``` List nearby stores in the 'pharmacy' category around coordinates 4.6097, -74.0817. ``` **Response:** ``` Grid scanned! I found 3 pharmacies capable of delivering to that specific coordinate set within ETA windows of under 30 minutes. Farmatodo (Store ID: f_91) has the lowest dynamic delivery fee. Should I extract their painkiller catalog next? ``` **Prompt:** ``` Check the delivery state and ETA for my active order number 8812920. ``` **Response:** ``` Tracking ping dispatched... Order 8812920 is currently in the 'Out for Delivery' state. The courier is 1.2 kilometers away, moving smoothly. Adjusted ETA sits exactly at 6 minutes from now without delays. Need me to authorize a tip? ``` **Prompt:** ``` Cancel the active order 88910 immediately citing missing items from the receipt. ``` **Response:** ``` Order cancellation request dispatched forcing priority queue... Order 88910 has been successfully aborted and zeroed out. The refund algorithm triggered automatically citing error 'Items Missing against receipt'. The credits should append to your vault safely. Want me to draft an escalated complaint? ``` ## Capabilities ### Manage Incoming Orders Your agent can accept new orders using `take_order`, signal readiness with `mark_ready_for_pickup`, or reject them immediately via `reject_order`. ### Check Store Status and Inventory You get real-time data on whether a store is accepting orders (`get_store_availability`) and can pull the full, current item catalog using `get_store_menu`. ### Track Full Order Details The agent pulls complete records for any order ID using `get_order_detail`, or retrieves necessary handoff codes using `get_order_handoff`. ### Automate Store Operations You can control the store's operational status by opening or closing it via `update_store_status`, or listing all registered locations using `list_stores`. ### Process New Orders Queue The agent lists new orders waiting for acceptance (`list_new_orders`) and can handle the core workflow of processing those incoming requests. ## Use Cases ### Handling a Surge of New Orders The store manager sees 50+ new incoming requests. Instead of manually clicking through them, the agent runs `list_new_orders`. The AI reads the list and automatically calls `take_order` for the first 48 orders while running `get_store_availability` to confirm no location is offline before accepting. ### Cross-Checking Menu Items A corporate client needs a quote on three different items from two separate stores. The agent runs `list_stores` to identify the IDs, then uses `get_store_menu` for each ID, and finally compares the pricing data in one place. ### Simulating Store Closures The store needs maintenance at 3 PM. The operations lead instructs the agent to run `update_store_status` (setting it to closed). When service resumes, the agent runs the same tool again, opening it up for orders. ### Investigating a Lost Shipment A customer reports an item is missing. The agent uses `get_order_detail` to pull the original order manifest and then checks the handoff confirmation codes using `get_order_handoff` against the recorded data to pinpoint where the breakdown occurred. ## Benefits - Manage the entire order lifecycle: Use `list_new_orders` to pull pending requests, and then use `take_order` or `reject_order` to process them instantly without opening a dashboard. This keeps your fulfillment team moving faster. - Control store operations on demand. If you need to close the location for inventory counts, run `update_store_status`. When it's open again, simply switch it back using the same tool. - Never miss an item or check a menu manually. The `get_store_menu` tool pulls the entire catalog instantly, allowing your agent to search specific items and cross-reference pricing data for market analysis. - Improve tracking reliability by calling `get_order_detail`. This gives you immediate access to deep order specifics, going beyond simple status updates to check full item lists or payment details. - Speed up deployment: Need to know what stores are even active? Use `list_stores` first. Then use `get_store_availability` on each one to confirm they can take orders before routing any workflow. ## How It Works The bottom line is: You feed the server your credentials, and your AI client handles all the complex API calls needed to run logistics operations. 1. First, you must secure developer approval directly through the Rappi Developer Hub and extract your core Client ID and Client Secret. 2. Next, plug these core credentials into the MCP Server environment. The server wraps all intensive REST endpoints so they appear as simple tool calls to your agent. 3. Finally, trigger a command—like `get_store_menu` or `list_new_orders`. Your agent executes the call and receives clean, natural text responses containing the necessary data. ## Frequently Asked Questions **How do I check if a store is open using get_store_availability?** You pass the Store ID to `get_store_availability`. The tool returns a simple status (open or closed) and confirms whether it's actively accepting new orders, giving you an immediate go/no-go decision. **What is the difference between list_new_orders and get_order_detail?** `list_new_orders` gives you a batch view—a quick list of IDs waiting for staff to accept them. `get_order_detail` requires a specific ID and pulls every piece of information about that single, existing order. **How do I make an agent accept a new order?** First, use `list_new_orders` to find the target order's ID. Then, you call `take_order(order_id)` with that ID. This officially accepts the order and begins the preparation process in the system. **Can I list all stores using list_stores?** Yes, running `list_stores` returns a comprehensive list of every registered store location under your account's purview. You can use these IDs for subsequent checks like `get_store_menu`. **If I use get_order_detail and the order ID is invalid or already canceled, what error response should my agent expect?** Expect an HTTP 4xx code if the order doesn't exist. The API usually returns a clear message detailing *why* it failed—like 'Order ID not found' or 'Status is closed.' Your agent needs to build in specific error handling for these cases. **What’s the operational difference between calling take_order and using mark_ready_for_pickup?** Taking an order officially accepts responsibility, which starts prep work. Marking it ready tells the courier that preparation is finished and the goods are staged for immediate pickup. They handle two different stages of the fulfillment process. **How do I secure my access when running bulk checks using get_store_menu or list_stores?** Start by securing your Client ID and Secret within the developer hub. These credentials govern all data requests, so treat them like highly sensitive passwords. Never expose these values in client-side code. **How can I avoid hitting rate limits when running bulk checks using get_store_availability?** You must implement a deliberate delay—a 'sleep' function—between sequential calls. Checking availability for dozens of stores too fast will trigger throttling. Always check the provider documentation for current rate limit guidelines. **Does order placement via the API bypass the normal Rappi checkout security rules?** No. The `place_order` tool uses your pre-authenticated method securely. Bank validations, anti-fraud algorithms, and location checks apply exactly as they would natively in the application avoiding compliance breaches entirely. **Can I explicitly track multiple concurrent active orders dynamically simultaneously?** Yes! Your agent can iterate over an array of active Order IDs using the `get_order_status` tool consistently. It parses coordinate updates and ETA drops, outputting a consolidated table summing up your entire inbound fleet seamlessly. **Are the store identifiers (storeId) universally stable across regions?** Store IDs are fundamentally unique keys generated explicitly by Rappi's catalog backend. They remain static for the lifetime of that specific branch location. Searching via `list_nearby_stores` initially is recommended to cache the correct target IDs dynamically.