Rappi API MCP. Automate Latin American Logistics & Orders.
Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
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.
What your AI agents can do
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.
Your agent can accept new orders using take_order, signal readiness with mark_ready_for_pickup, or reject them immediately via reject_order.
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.
The agent pulls complete records for any order ID using get_order_detail, or retrieves necessary handoff codes using get_order_handoff.
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.
The agent lists new orders waiting for acceptance (list_new_orders) and can handle the core workflow of processing those incoming requests.
Ask AI about this MCP
Supported MCP Clients
Waiting for input…
Rappi API: 10 Tools for Logistics Management
Run core operations—from checking inventory with `get_store_menu` to processing new orders with `take_order`—using these dedicated tools.
019d8475get order detail
Retrieves all specific information about a single, existing order using its ID.
019d8475get order handoff
Gets the required confirmation codes needed to validate or finalize an order handoff process.
019d8475get store availability
Checks and reports the current operational status (open/closed) of a specific store location.
019d8475get store menu
Pulls the complete, up-to-date list of items available for sale at a given store ID.
019d8475list new orders
Retrieves a batch list of all incoming orders that are currently awaiting acceptance by staff.
019d8475list stores
Lists every registered store location associated with your operational account ID.
019d8475mark ready for pickup
Sends a signal to the system that an accepted order is physically prepared and ready for the courier.
019d8475reject order
Declines an incoming order immediately, requiring you to provide a specific reason for rejection in the payload.
019d8475take order
Accepts and officially starts preparation for a newly received incoming order ID.
019d8475update store status
Changes the operational status of an entire store—either opening it or closing it to prevent new orders.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Rappi API, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
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.
How Rappi API MCP Works
- 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_menuorlist_new_orders. Your agent executes the call and receives clean, natural text responses containing the necessary data.
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.
Who Is Rappi API MCP For?
This toolkit is for Operations Managers, Supply Chain Analysts, and SaaS Integrators who are tired of manual data entry or relying on unstable front-end scraping. If your workflow involves high-volume, time-sensitive logistics in Latin America, this server gives you the direct control layer you need.
You use get_store_availability and list_stores to build comparative dashboards that model delivery network capacity across different urban hubs.
On a busy day, you let the agent run list_new_orders and then use take_order or reject_order to manage incoming workflow without touching a dashboard.
You schedule large-scale corporate food deliveries by using the agent to query menus (get_store_menu) and place nested orders for multiple departments simultaneously.
What Changes When You Connect
- Manage the entire order lifecycle: Use
list_new_ordersto pull pending requests, and then usetake_orderorreject_orderto 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_menutool 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_storesfirst. Then useget_store_availabilityon each one to confirm they can take orders before routing any workflow.
Real-World 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.
The Tradeoffs
Relying on Web Scraping
Trying to run a script that mimics clicking through Rappi's public-facing website. This fails immediately when they update their UI or if the network connection drops.
→
Use the official API endpoints via this server. For example, instead of scraping, call get_order_detail directly with the order ID to get guaranteed data access.
Only Checking One Store
Needing to know if three different branches can deliver but only running a single status check. You miss critical operational gaps.
→
First, run list_stores to get all relevant IDs. Then, loop through that list and call get_store_availability on every ID to build a comprehensive map.
Assuming Order Status
Thinking an order is processed just because it exists in the database. You don't know if staff accepted it or if handoff was required.
→
Always confirm status by calling list_new_orders to see what requires action, and then use get_order_handoff before marking anything as complete.
When It Fits, When It Doesn't
Use this server if your workflow absolutely depends on the reliable, structured data from Rappi’s backend system—things like order acceptance/rejection, real-time status checks, or menu catalogs. You should use it when you need to execute an action (like take_order) or fetch a core record (get_order_detail).
Don't use this server if your goal is simple data logging that doesn't require state change; for pure analytics over historical, non-transactional records, other database connectors might be better. Also, if you only need to know the name of a store and nothing else, simply querying a local address book avoids the overhead of calling list_stores. This tool is built for action within the live Rappi ecosystem.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Rappi API. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Dealing with logistics means constant state changes. It shouldn't require opening 5 different tabs just to confirm if an order can move forward.
Today, managing a shipment is a mess of clicks: You check the store's hours on one screen, then go to another tab to see if any orders are pending. If you need the menu for pricing, it’s a third click, and if an order came in while you were doing all that, you missed it until you manually refreshed.
With this MCP server, your agent handles the entire chain. You ask: 'Can I process this order?' The agent runs `get_store_availability` first, confirms status, then calls `list_new_orders`. It gives you a clean yes/no answer and the data needed to act immediately—all in one prompt.
The Rappi API MCP Server: Control order flow with just your words.
You no longer have to simulate a human worker's actions. There’s no more refreshing the page every 30 seconds or copying an ID from one screen and pasting it into another form. You tell the agent what needs doing, and it executes the sequence of calls—be it `take_order` followed by `get_order_detail`.
This means your workflow is reliable, repeatable, and fast. It takes manual labor out of the equation entirely.
Common Questions About Rappi API MCP
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Cloudflare Stream
Manage video infrastructure via Cloudflare Stream—list videos, manage live inputs, and handle uploads directly from any AI agent.
Postmark Alternative
Automate transactional email via Postmark — send emails, retrieve templates, inspect bounces, and manage your delivery analytics directly from any AI agent.
GrabFood Partner
Automate GrabFood restaurant operations — manage orders, update menus, control store status, and run marketing campaigns directly from any AI agent.
You might also like
Fluxguard
Monitor website changes, track visual differences, and receive alerts via AI agents with Fluxguard.
Calendly Alternative
Manage meetings and scheduling via Calendly — list event types, track scheduled events, inspect invitees and manage webhooks from any AI agent.
Open Food Facts API
Search food products — audit nutrition, barcode, and categories via AI.