4,500+ servers built on MCP Fusion
Vinkius

Uber Eats MCP. Manage order flow and inventory across all locations.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Uber Eats MCP on Cursor AI Code Editor MCP Client Uber Eats MCP on Claude Desktop App MCP Integration Uber Eats MCP on OpenAI Agents SDK MCP Compatible Uber Eats MCP on Visual Studio Code MCP Extension Client Uber Eats MCP on GitHub Copilot AI Agent MCP Integration Uber Eats MCP on Google Gemini AI MCP Integration Uber Eats MCP on Lovable AI Development MCP Client Uber Eats MCP on Mistral AI Agents MCP Compatible Uber Eats MCP on Amazon AWS Bedrock MCP Support

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.

+ 11 more capabilities included
Manage order status transitions

Accept, reject, or cancel orders and update their lifecycle status from pending to delivered.

Maintain real-time menu inventory

Toggle item availability (in/out of stock) and view the complete catalog structure for a specific restaurant.

Monitor delivery logistics

Get live GPS tracking updates, estimated times of arrival (ETA), and status details for active deliveries.

Review order specifics and issues

Retrieve full customer information, item lists, and a history of reported complaints or refunds associated with an order.

Query store configuration data

Check the operational status, addresses, and general setup details for all registered restaurant locations.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

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.

accept019d7617

accept order

Confirms a pending Uber Eats order is being prepared and triggers the initial courier assignment notification.

cancel019d7617

cancel order

Cancels an already accepted order, which requires providing a specific cancellation reason code.

complete019d7617

complete order

Finalizes the order lifecycle after successful delivery and triggers final payment processing for accounting records.

get019d7617

get delivery status

Provides real-time location, estimated time of arrival (ETA), and current status updates for an active delivery.

get019d7617

get menus

Retrieves the full catalog structure for a specific restaurant, including item IDs needed for inventory changes.

get019d7617

get order

Pulls all details—items, instructions, totals—for one specific delivery order before staff begins preparation.

get019d7617

get order issues

Retrieves a list of reported complaints and issue timestamps for an order, helping you address disputes proactively.

get019d7617

get orders

Lists all orders for your restaurants, allowing filtering by status (PENDING, READY, DELIVERED, etc.) to track the entire workflow.

get019d7617

get store

Gets detailed operational information and configuration settings for a single restaurant location.

get019d7617

get stores

Lists all associated store IDs, names, and addresses across your entire merchant account portfolio.

mark019d7617

mark order prep started

Changes the order status to 'PREPARING' and notifies the customer that kitchen staff have begun work on the meal.

mark019d7617

mark order ready

Signals that the food is packaged and ready for pickup, triggering the courier dispatch notification.

reject019d7617

reject order

Declines a pending order using a specific reason code (e.g., 'too_busy') so the customer knows why it wasn't fulfilled.

update019d7617

update 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
Start building

Make Your AI Do More

Start with Uber Eats, 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

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.

How Uber Eats MCP Works

  1. 1 Connect your Uber Eats merchant account using an OAuth token from the Developer Portal.
  2. 2 Ask your agent to perform a task (e.g., 'Check my pending orders and mark them as ready for pickup').
  3. 3 The agent executes multiple, precise tool calls (get_orders, then mark_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.

Multi-location Franchise Owner

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.

Kitchen Manager / Shift Lead

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.

Restaurant Operations Director

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_orders to 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_availability toggles stock status across the platform in seconds.
  • Don't wait for customer calls about delays. Use get_delivery_status to pull real-time courier location and ETA directly into your workflow, giving customers proactive updates.
  • Audit every problem without calling support. Running get_order_issues pulls 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_order to running mark_order_prep_started, guiding the kitchen through the process.

Real-World Use Cases

01

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.

02

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.

03

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.

04

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.

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

How we secure it →

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.

Available Capabilities

accept_order cancel_order complete_order get_delivery_status get_menus get_order get_order_issues get_orders get_store get_stores mark_order_prep_started mark_order_ready reject_order update_menu_item_availability

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.

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.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 14 tools

We've already built the connector for Uber Eats. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 14 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.