# Uber Eats MCP > 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. ## Overview - **Category:** industry-titans - **Price:** Free - **Tags:** order-management, menu-management, delivery-tracking, merchant-services, real-time-monitoring ## Description 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. ## Tools ### 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. ### get_delivery_status Provides real-time location, estimated time of arrival (ETA), and current status updates for an active delivery. ### get_menus Retrieves the full catalog structure for a specific restaurant, including item IDs needed for inventory changes. ### get_order Pulls all details—items, instructions, totals—for one specific delivery order before staff begins preparation. ### get_order_issues Retrieves a list of reported complaints and issue timestamps for an order, helping you address disputes proactively. ### get_orders Lists all orders for your restaurants, allowing filtering by status (PENDING, READY, DELIVERED, etc.) to track the entire workflow. ### get_store Gets detailed operational information and configuration settings for a single restaurant location. ### get_stores Lists all associated store IDs, names, and addresses across your entire merchant account portfolio. ### mark_order_prep_started Changes the order status to 'PREPARING' and notifies the customer that kitchen staff have begun work on the meal. ### mark_order_ready Signals that the food is packaged and ready for pickup, triggering the courier dispatch notification. ### reject_order Declines a pending order using a specific reason code (e.g., 'too_busy') so the customer knows why it wasn't fulfilled. ### update_menu_item_availability Toggles an item's availability status—marking it as in-stock or out-of-stock—using its unique menu ID. ## Prompt Examples **Prompt:** ``` Show me all pending orders and accept them automatically ``` **Response:** ``` I'll check your pending orders and accept them right away. ``` **Prompt:** ``` Update the price of 'Margherita Pizza' to R$45.90 and mark it as unavailable ``` **Response:** ``` I'll update the menu item price and toggle its availability. ``` **Prompt:** ``` Track the delivery status of order #12345 and tell me where the courier is ``` **Response:** ``` I'll get real-time delivery tracking with courier location and ETA. ``` ## Capabilities ### 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. ## 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. ## Benefits - 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. ## How It Works 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. 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`, then `mark_order_ready`), handling the entire workflow. ## Frequently Asked Questions **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.