Uber Eats MCP. Manage order flow and inventory across all locations.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Uber Eats MCP Server connects your AI client to the full Uber Eats Merchant API. Manage everything from accepting incoming orders and updating menus to tracking live delivery locations and handling customer complaints—all through natural language commands.
It lets your agent run the entire restaurant operation cycle, eliminating manual dashboard navigation.
What your AI agents can do
Accept order
Confirms a pending Uber Eats order is being prepared and triggers the initial courier assignment notification.
Cancel order
Cancels an already accepted order, which requires providing a specific cancellation reason code.
Complete order
Finalizes the order lifecycle after successful delivery and triggers final payment processing for accounting records.
Accept, reject, or cancel orders and update their lifecycle status from pending to delivered.
Toggle item availability (in/out of stock) and view the complete catalog structure for a specific restaurant.
Get live GPS tracking updates, estimated times of arrival (ETA), and status details for active deliveries.
Retrieve full customer information, item lists, and a history of reported complaints or refunds associated with an order.
Check the operational status, addresses, and general setup details for all registered restaurant locations.
Ask AI about this MCP
Supported MCP Clients
OAuth 2.0 Compatible Gemini Waiting for input…
Uber Eats MCP Server: 14 Tools for Restaurant Management
These tools let your agent run complex, multi-step operations across order fulfillment, menu updates, and real-time delivery tracking.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Uber Eats on Vinkius019d7617accept order
Confirms a pending Uber Eats order is being prepared and triggers the initial courier assignment notification.
019d7617cancel order
Cancels an already accepted order, which requires providing a specific cancellation reason code.
019d7617complete order
Finalizes the order lifecycle after successful delivery and triggers final payment processing for accounting records.
019d7617get delivery status
Provides real-time location, estimated time of arrival (ETA), and current status updates for an active delivery.
019d7617get menus
Retrieves the full catalog structure for a specific restaurant, including item IDs needed for inventory changes.
019d7617get order
Pulls all details—items, instructions, totals—for one specific delivery order before staff begins preparation.
019d7617get order issues
Retrieves a list of reported complaints and issue timestamps for an order, helping you address disputes proactively.
019d7617get orders
Lists all orders for your restaurants, allowing filtering by status (PENDING, READY, DELIVERED, etc.) to track the entire workflow.
019d7617get store
Gets detailed operational information and configuration settings for a single restaurant location.
019d7617get stores
Lists all associated store IDs, names, and addresses across your entire merchant account portfolio.
019d7617mark order prep started
Changes the order status to 'PREPARING' and notifies the customer that kitchen staff have begun work on the meal.
019d7617mark order ready
Signals that the food is packaged and ready for pickup, triggering the courier dispatch notification.
019d7617reject order
Declines a pending order using a specific reason code (e.g., 'too_busy') so the customer knows why it wasn't fulfilled.
019d7617update menu item availability
Toggles an item's availability status—marking it as in-stock or out-of-stock—using its unique menu ID.
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 Uber Eats, then connect any of our 4,800+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,800+ 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
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Uber Eats. 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 14 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Handling order flow shouldn't involve jumping between five different screens.
Right now, accepting an order means opening the Uber Eats Manager app, finding the specific pending ticket, clicking 'Accept,' then maybe checking another tab to see if you need to update that pizza item's price because you're short on cheese. It’s a messy, multi-click dance every single time.
With this MCP server, your agent handles it all. You just tell it: 'Process the next batch of orders.' The agent runs `get_orders`, checks capacity, executes `accept_order`, and can even run `update_menu_item_availability` if prices need adjusting—all without you touching a single dashboard.
Marking an order as ready using `mark_order_ready` sends the right signals.
Manually signaling that food is packaged and waiting for pickup can be done with a physical sign, but that doesn't notify the courier system. You have to remember to switch status screens or call someone on the phone just to make sure they know it’s ready.
The agent handles this signal perfectly. Calling `mark_order_ready` does more than change a status—it triggers the official courier dispatch notification, guaranteeing the next person knows exactly where and when to pick up.
What you can do with this MCP connector
This MCP Server connects your AI client directly to the full Uber Eats Merchant API. You get complete operational control—managing orders, updating menus, and handling store logistics—all through natural language commands. Your agent can run the entire restaurant cycle without you having to click around in a dashboard.
Managing Order Flow: From Ping to Paycheck
You handle the whole order lifecycle right here. First, you use get_orders to list every single delivery across all your locations, letting you filter by status—PENDING, READY, DELIVERED, and everything in between. When a new order comes in, you pull all the details for that specific job using get_order, which gives you the item list, instructions, and total amount before staff even start prepping.
If the kitchen is swamped or something’s wrong with the ticket, your agent can decline it immediately using reject_order and provide a required reason code. If an order was accepted but needs to be scrapped entirely, you use cancel_order, which forces you to specify a cancellation reason code for records.
When everything looks good, you confirm preparation starts by calling mark_order_prep_started; that tells the customer and the system your staff are on it. Once the food is packaged up and ready to go, you signal this using mark_order_ready, which triggers the courier dispatch notification. When the meal finally lands at the door, you use complete_order to finalize the order's record and trigger final payment processing for accounting.
Monitoring Deliveries and Issues
Tracking is simple. You get real-time location data, estimated time of arrival (ETA), and status updates for every active delivery using get_delivery_status. If there’s a dispute or complaint attached to an order, you don't have to guess what happened; calling get_order_issues pulls up the list of reported complaints and timestamps so you can address it head-on.
You can also check the general operational status for your entire set of locations using get_stores, or dive into specific setup details for one spot with get_store.
Inventory Control and Menu Updates
You control what's on the menu and if it's available. Before you mess with anything, you can pull the full catalog structure for a location using get_menus, which gives you all the necessary item IDs needed to make changes later. To update stock levels, your agent uses update_menu_item_availability—you just toggle an item’s status as in-stock or out-of-stock using its unique menu ID.
The Process In Action
Your AI client takes the whole mess of operational data and turns it into simple actions. It reads all the tools, understands your intent—like 'Accept pending orders for Store B and mark the lasagna unavailable'—and runs those necessary functions sequentially. It handles everything from accepting an order via accept_order to updating inventory through update_menu_item_availability, letting you manage every part of the restaurant operation with plain language commands.
019d7617-9a5b-73db-b3c3-a7ea56cf0da4 
How Uber Eats MCP Works
- 1 Connect your Uber Eats merchant account using an OAuth token from the Developer Portal.
- 2 Ask your agent to perform a task (e.g., 'Check my pending orders and mark them as ready for pickup').
- 3 The agent executes multiple, precise tool calls (
get_orders, thenmark_order_ready), handling the entire workflow.
The bottom line is: you tell your AI client what needs to happen—like 'Accept all pending orders and update pizza prices'—and it runs the necessary API sequence for you.
Who Is Uber Eats MCP For?
This is essential for multi-location franchise owners or restaurant managers who are tired of logging into five different dashboards just to process a day’s worth of orders. If your job involves coordinating logistics, inventory changes, and real-time customer issue resolution across multiple sites, you need this.
Uses the agent to check get_stores for all location IDs, then uses those IDs with get_menus to batch update pricing and availability across every site.
Relies on the agent to monitor incoming orders via get_orders, accept them immediately using accept_order, and then use mark_order_prep_started when the kitchen gets busy.
Uses this server to audit performance by calling get_order_issues on high-volume orders, allowing them to track customer complaints and process necessary refunds quickly.
What Changes When You Connect
- Stop manually clicking through status updates. Use
get_ordersto pull every pending, accepted, or rejected order into one stream, letting your agent act on them instantly. - When ingredients run low, you don't have to physically mark items off a whiteboard. Calling
update_menu_item_availabilitytoggles stock status across the platform in seconds. - Don't wait for customer calls about delays. Use
get_delivery_statusto pull real-time courier location and ETA directly into your workflow, giving customers proactive updates. - Audit every problem without calling support. Running
get_order_issuespulls historical records of complaints and refunds attached to a specific order ID. - Streamline the operational handoff. The agent can manage the status changes: from using
accept_orderto runningmark_order_prep_started, guiding the kitchen through the process.
Real-World Use Cases
The Rush Hour Order Triage
A shift lead gets 20 new orders. Instead of opening the app 20 times, they ask their agent to run get_orders filtered by PENDING. The agent reviews the list and executes accept_order for all viable meals in a single command.
Inventory Crisis Management
The baker runs out of croissants mid-shift. Instead of manually updating every menu board, they tell their agent to use update_menu_item_availability on the specific croissant ID, making it instantly unavailable for all customers.
Investigating a Bad Delivery
A customer complains about cold food. The manager uses the agent to run get_order_issues using the order number, immediately pulling up timestamps and details on the complaint, which helps determine if it was a prep issue or a delivery delay.
Closing Out Day's Sales
The end-of-shift report requires proof of delivery. The agent pulls all completed orders using get_orders and executes complete_order for the batch, ensuring final payment processing is logged correctly.
The Tradeoffs
Treating statuses as single actions
Trying to just 'update status to ready' without first confirming preparation. This fails because you need specific, sequential steps.
→
You must use mark_order_prep_started first, then wait until food is packaged before calling mark_order_ready. The tools enforce this proper workflow.
Ignoring inventory checks
Accepting an order for a specific item when the kitchen knows that ingredient ran out 10 minutes ago.
→
Always check get_menus first. If the item is unavailable, you must run reject_order and specify the reason code 'item_unavailable'.
Over-relying on single status checks
Just calling get_delivery_status repeatedly to guess what's wrong. This is inefficient and doesn't capture context.
→
Use the combined power of get_orders (to get order details) and then follow up with get_delivery_status for current location tracking.
When It Fits, When It Doesn't
You need this server if your business depends on managing a complex, multi-stage operational cycle that spans from the customer placing an order to the food being delivered. Specifically, you must manage inventory (requires update_menu_item_availability), track live logistics (get_delivery_status), and handle status transitions (accept_order through complete_order).
Don't use this if your need is simple: If you only ever need to know 'What are my pending orders?'—a basic list might suffice. But since you need to act on those orders (e.g., accepting them, updating the menu), this full suite of 14 tools gives you granular control over every single step. It's built for operational complexity, not simple data retrieval.
Common Questions About Uber Eats MCP
How do I process orders using get_orders? +
Use get_orders first to list all pending order IDs and their current statuses. Then, you can tell the agent which specific actions to take on those IDs, like accepting them via accept_order.
What is the difference between reject_order and cancel_order? +
There's a key difference: You use reject_order when an order hasn't been accepted yet (e.g., ingredient shortage). You only call cancel_order after the restaurant has already accepted it.
Can I check menu prices for multiple locations? +
You must first run get_stores to get all required location IDs. Then, you can use those IDs when calling get_menus to pull the catalog for every site.
How do I handle a customer complaint using get_order_issues? +
Call get_order_issues with the order ID. This returns structured data about complaints, including timestamps and if any refunds were already processed, helping you respond accurately.
Before I can use tools like `update_menu_item_availability`, how do I get all the required store IDs? +
You must run get_stores first. This tool lists every external store ID, name, and address associated with your account. You need these specific IDs to reference any menu or order management actions for a given location.
What is the correct sequence of events after I accept an incoming order using `accept_order`? +
After accepting, you should immediately use mark_order_prep_started. This updates the customer and system that cooking has begun. You then wait for food to finish before calling mark_order_ready.
How do I check if a menu item is currently in stock using `get_menus`? +
The get_menus tool provides the full catalog and includes current availability flags. If an item is flagged as unavailable, you should use update_menu_item_availability to change its status before it gets ordered.
When exactly do I call `complete_order` for a delivery? +
Only run complete_order after the courier confirms successful drop-off and payment has been finalized. Calling this too early will interrupt the financial closing process for the order.
Does this work for Uber Eats customers or only merchants? +
This MCP server is designed exclusively for Uber Eats merchants (restaurant owners). It uses the Uber Eats Marketplace API to manage orders, menus, deliveries, and store operations. Consumer-side features (browsing restaurants, placing orders) require the Uber consumer app. If you're a restaurant owner using Uber Eats for delivery, this is for you.
Can I automatically accept all incoming orders? +
Yes! AI agents can monitor pending orders and auto-accept them based on your criteria. You can set up automation rules to accept orders instantly during business hours, reject when kitchen is at capacity, or flag special instructions for manual review. This significantly reduces response times and improves restaurant ratings on the platform.
Does this support multiple restaurant locations? +
Absolutely. The API returns all stores associated with your merchant account. Each tool requires a store_id parameter, so you can manage operations independently across all your restaurant locations. AI agents can list all your stores first to get their IDs, then manage menus, orders, and settings for each location separately.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.