How do I get my GrabFood Merchant ID?

Your Merchant ID is provided when you register as a GrabFood Partner. You can find it in the GrabFood Partner Portal under your restaurant settings, or in the welcome email you received when your restaurant was onboarded to GrabFood.

Can I use this integration in production, not just sandbox?

Yes! The integration defaults to the GrabFood sandbox environment for safe testing. To switch to production, you'll need to update the base URL in the engine configuration to the production endpoint. Contact GrabFood Partner support for production API credentials.

What happens if I reject an order? Does it affect my merchant rating?

Rejecting orders may impact your merchant performance metrics on GrabFood. Frequent rejections can lead to lower visibility in search results. It's recommended to only reject orders when absolutely necessary (e.g., item out of stock, kitchen closure). Always verify order details before making a decision.

Can I update menu items individually without replacing the entire menu?

Yes! Use the `batch_update_menu` tool for targeted updates to specific items, prices, or availability. This is safer than a full menu replacement since it only touches the items you specify. Use `update_menu` only when you need to replace the entire menu structure.

How do I get my OAuth2 access token for the GrabFood Partner API?

You can obtain your OAuth2 access token through the GrabFood Partner Portal. Log in to your partner account and navigate to API Settings or Developer section to generate or retrieve your token. If you don't have access, contact your GrabFood Partner account manager.

GrabFood Partner MCP Server for AutoGen 12 tools — connect in under 2 minutes

Name: GrabFood Partner
Availability: InStock
Author: Vinkius

microsoft.github.io/autogen/docs/tools/mcp-tools

Built by Vinkius GDPR 12 Tools Framework

Microsoft AutoGen enables multi-agent conversations where agents negotiate, delegate, and execute tasks collaboratively. Add GrabFood Partner as an MCP tool provider through Vinkius and every agent in the group can access live data and take action.

Get MCP Server for AI Agents

ASK AI ABOUT THIS MCP SERVER

Open in ChatGPT Open in Claude Open in Perplexity

Vinkius supports streamable HTTP and SSE.

python

import asyncio
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.tools.mcp import McpWorkbench

async def main():
    # Your Vinkius token. get it at cloud.vinkius.com
    async with McpWorkbench(
        server_params={"url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"},
        transport="streamable_http",
    ) as workbench:
        tools = await workbench.list_tools()
        agent = AssistantAgent(
            name="grabfood_partner_agent",
            tools=tools,
            system_message=(
                "You help users with GrabFood Partner. "
                "12 tools available."
            ),
        )
        print(f"Agent ready with {len(tools)} tools")

asyncio.run(main())

Fully ManagedVinkius Servers

60%Token savings

High SecurityEnterprise-grade

IAMAccess control

EU AI ActCompliant

DLPData protection

V8 IsolateSandboxed

Ed25519Audit chain

<40msKill switch

Stream every event to Splunk, Datadog, or your own webhook in real-time

* Every MCP server runs on Vinkius-managed infrastructure inside AWS - a purpose-built runtime with per-request V8 isolates, Ed25519 signed audit chains, and sub-40ms cold starts optimized for native MCP execution. See our infrastructure

About GrabFood Partner MCP Server

Connect your GrabFood Partner account to any AI agent and take full control of your restaurant delivery operations through natural conversation.

AutoGen enables multi-agent conversations where agents negotiate, delegate, and collaboratively use GrabFood Partner tools. Connect 12 tools through Vinkius and assign role-based access. a data analyst queries while a reviewer validates, with optional human-in-the-loop approval for sensitive operations.

What you can do

Order Management — List all incoming orders, accept or reject them, cancel when necessary, and mark orders as ready for pickup
Order Lifecycle Control — Check if orders can be cancelled, update estimated ready times, and manage delivery states
Menu Management — Update your entire menu or perform targeted batch updates to specific items, prices, and availability
Store Operations — Check your store's real-time status, view operating hours, and pause/unpause your store instantly
Marketing Campaigns — List existing campaigns and create new promotional campaigns to boost visibility and orders

The GrabFood Partner MCP Server exposes 12 tools through the Vinkius. Connect it to AutoGen in under two minutes — no API keys to rotate, no infrastructure to provision, no vendor lock-in. Your configuration, your data, your control.

How to Connect GrabFood Partner to AutoGen via MCP

Follow these steps to integrate the GrabFood Partner MCP Server with AutoGen.

Install AutoGen

Run pip install "autogen-ext[mcp]"

Replace the token

Replace [YOUR_TOKEN_HERE] with your Vinkius token

Integrate into workflow

Use the agent in your AutoGen multi-agent orchestration

Explore tools

The workbench discovers 12 tools from GrabFood Partner automatically

Why Use AutoGen with the GrabFood Partner MCP Server

AutoGen provides unique advantages when paired with GrabFood Partner through the Model Context Protocol.

Multi-agent conversations: multiple AutoGen agents discuss, delegate, and collaboratively use GrabFood Partner tools to solve complex tasks

Role-based architecture lets you assign GrabFood Partner tool access to specific agents. a data analyst queries while a reviewer validates

Human-in-the-loop support: agents can pause for human approval before executing sensitive GrabFood Partner tool calls

Code execution sandbox: AutoGen agents can write and run code that processes GrabFood Partner tool responses in an isolated environment

GrabFood Partner + AutoGen Use Cases

Practical scenarios where AutoGen combined with the GrabFood Partner MCP Server delivers measurable value.

Collaborative analysis: one agent queries GrabFood Partner while another validates results and a third generates the final report

Automated review pipelines: a researcher agent fetches data from GrabFood Partner, a critic agent evaluates quality, and a writer produces the output

Interactive planning: agents negotiate task allocation using GrabFood Partner data to make informed decisions about resource distribution

Code generation with live data: an AutoGen coder agent writes scripts that process GrabFood Partner responses in a sandboxed execution environment

GrabFood Partner MCP Tools for AutoGen (12)

These 12 tools become available when you connect GrabFood Partner to AutoGen via MCP:

accept_order

This is a critical operational tool for restaurant staff to manage order flow. When set to accept=true, the restaurant confirms it will prepare the order. When accept=false, the order is rejected and the customer is notified. **Parameters:** - `order_id` (required): The unique order ID from GrabFood that needs to be accepted or rejected. - `accept` (required): Boolean flag — true to accept the order, false to reject it. **When to use:** - User says "accept order 12345" to confirm they will prepare it - User says "reject order 12345" if the restaurant cannot fulfill the order (e.g., items out of stock, kitchen closed) - User wants to bulk-accept multiple orders during busy periods - User needs to decline an order due to operational constraints **Important:** Accepting an order commits the restaurant to preparing it. Rejecting may impact the merchant's performance metrics on the GrabFood platform. Always verify order details before accepting. Accept or reject a GrabFood order

batch_update_menu

This is the preferred tool for making incremental changes — such as updating prices for a few items, marking items as available/unavailable, or modifying descriptions. **Parameters:** - `merchant_id` (required): The unique merchant ID registered with GrabFood. - `items` (required): An array of item update objects. Each object should contain the item identifier and the fields to update (e.g., price, availability, name, description). **When to use:** - User needs to update prices for only a subset of menu items - User wants to mark several items as sold out without touching the full menu - User wants to update descriptions or names for specific dishes - Incremental daily changes (e.g., "mark items X, Y, Z as unavailable today") - User wants to avoid the risk of a full menu replacement **Important:** This is safer than a full menu update because it only touches the items you specify. Each item in the batch should include its identifier (e.g., item_id or sku) and only the fields that need changing. Batch update specific menu items for a GrabFood merchant

cancel_order

This should be used sparingly as cancellations negatively impact the merchant's performance score on GrabFood. Always verify the order can be cancelled before attempting. **Parameters:** - `order_id` (required): The unique order ID of the order to cancel. - `reason` (optional): A brief explanation for why the order is being cancelled. Providing a reason is recommended for audit purposes (e.g., "item out of stock", "kitchen equipment failure", "customer request"). **When to use:** - User discovers an item is out of stock after accepting an order - User needs to cancel due to unforeseen kitchen issues - Customer has requested a cancellation - Duplicate order was accidentally accepted **Important:** Before cancelling, consider using `check_order_cancelable` to verify if the order is still in a cancellable state. Once the order has progressed too far in preparation, cancellation may not be possible. Cancel an already accepted GrabFood order

check_order_cancelable

This is a safety check tool that should be used before attempting to cancel an order, as cancellations after a certain point in the order lifecycle are not permitted. **Parameters:** - `order_id` (required): The unique order ID to check for cancellation eligibility. **When to use:** - Before cancelling an order to avoid API errors - User asks "can I still cancel order 12345?" - Restaurant staff needs to verify order state before making a cancellation decision - User is uncertain whether the order has progressed beyond the cancellation window **Returns:** A status object indicating whether the order can be cancelled, along with any relevant state information. Check if a GrabFood order can still be cancelled

create_campaign

Campaigns can include discounts, free delivery offers, featured placement, and other promotional tools designed to increase order volume and visibility. **Parameters:** - `merchant_id` (required): The unique merchant ID registered with GrabFood. - `campaign` (required): The campaign configuration as a JSON object. This typically includes campaign name, type (e.g., discount, free delivery), budget, start/end dates, target audience, and any specific promotional parameters. **When to use:** - User wants to launch a promotional discount to boost order volume - User needs to set up a free delivery campaign for a limited period - Restaurant is opening a new location and wants featured placement - User wants to run a time-limited promotional offer (e.g., "20% off this weekend") **Important:** Campaign creation may require budget approval from GrabFood. Ensure the campaign configuration matches GrabFood's accepted campaign types and schemas. Review campaign details carefully before submitting, as changes may not be possible after creation. Create a new marketing campaign for a GrabFood merchant

get_store_status

This includes whether the store is currently open, paused, or closed, along with any status flags that affect order acceptance. **Parameters:** - `merchant_id` (required): The unique merchant ID registered with GrabFood. **When to use:** - User asks "is my store currently open on GrabFood?" - User wants to verify the store's visibility to customers - Before opening or closing, to check the current state - User wants to troubleshoot why orders are not coming in - User needs to audit store operational status **Returns:** A status object containing the store's current state (open/closed/paused), any active flags, and potentially operational metadata like current order capacity. Get the current operational status of a GrabFood store

list_campaigns

Campaigns on GrabFood are used to promote the restaurant through discounts, free delivery, featured placement, and other marketing initiatives. **Parameters:** - `merchant_id` (required): The unique merchant ID registered with GrabFood. **When to use:** - User asks "what campaigns am I currently running on GrabFood?" - User wants to review the performance of past marketing campaigns - User needs to see active promotions before creating a new one - User wants to audit their marketing spend on GrabFood **Returns:** A JSON array of campaign objects, each containing campaign details such as name, type, budget, duration, status, and performance metrics. List all marketing campaigns for a GrabFood merchant

list_orders

Use this tool when the user wants to see what orders have been placed, check today's order volume, or review incoming orders from GrabFood delivery customers. **Parameters:** - `merchant_id` (required): The unique merchant ID registered with GrabFood Partner Portal. This identifies which restaurant's orders to fetch. - `date` (optional): The date to filter orders by, in YYYY-MM-DD format. If not provided, the API returns the most recent orders. **When to use:** - User asks "what orders do I have today?" - User wants to check order history for a specific date - User needs to see all incoming GrabFood orders before accepting them - User wants to audit order volume for a given day **Returns:** A JSON array of order objects, each containing order_id, items, customer details, delivery information, and order status. List all GrabFood orders for a merchant on a specific date

mark_order_ready

This is a crucial step in the order lifecycle — it notifies Grab that the driver should arrive immediately. **Parameters:** - `order_id` (required): The unique order ID that has been prepared and is ready for collection. **When to use:** - Kitchen has finished preparing all items in the order - User says "order 12345 is ready for pickup" - User wants to notify Grab that the driver should come now - All items have been packed and verified against the order **Important:** Only mark an order as ready when it is genuinely complete. Premature marking causes driver arrival before food is ready, leading to poor customer experience and potential quality issues (cold food, etc.). Mark a GrabFood order as ready for pickup/delivery

pause_store

When paused, the store will not receive new orders from GrabFood customers. When unpaused (pause=false), the store becomes visible and active again. **Parameters:** - `merchant_id` (required): The unique merchant ID registered with GrabFood. - `pause` (required): Boolean flag — true to pause the store, false to unpause it. **When to use:** - User says "pause my GrabFood store" — e.g., kitchen is overwhelmed, staff shortage, or end of business day - User says "unpause my store" or "open my store" when ready to receive orders again - Emergency closure due to equipment failure, power outage, or other disruptions - User wants to temporarily stop accepting orders during a rush **Important:** Pausing the store immediately stops new orders from being placed. Existing active orders are not affected. Always verify the store status after pausing/unpausing using `get_store_status` to confirm the change took effect. Pause or unpause a GrabFood store

update_menu

This tool replaces or modifies menu items, categories, pricing, and availability. It is a full update operation — ensure all desired menu data is included in the payload. **Parameters:** - `merchant_id` (required): The unique merchant ID registered with GrabFood. - `menu` (required): The complete menu data structure to update. This typically includes categories, items, prices, descriptions, images, and availability flags. The exact structure depends on the GrabFood menu schema. **When to use:** - User wants to add new dishes or remove discontinued items - User needs to update prices across the menu - Restaurant is changing its operating menu (e.g., seasonal items) - User needs to mark certain items as unavailable temporarily - User wants to update item descriptions or images **Important:** This is a full update operation. If you need to update only specific items without affecting the rest of the menu, consider using `batch_update_menu` instead. Ensure the menu data structure matches GrabFood's expected schema to avoid rejection. Update the menu for a GrabFood merchant

update_ready_time

This helps Grab optimize driver dispatch timing so the driver arrives when the food is actually ready, not too early or too late. **Parameters:** - `order_id` (required): The unique order ID whose ready time needs updating. - `ready_time` (required): The new estimated ready time in ISO 8601 format (e.g., "2024-01-15T14:30:00+07:00"). This should be a future timestamp representing when the order will be ready. **When to use:** - Kitchen is running behind schedule and the original estimate is no longer accurate - User wants to push back the ready time due to high order volume - Complex items are taking longer than expected to prepare - User wants to proactively manage driver dispatch timing **Important:** The ready_time should be in ISO 8601 format with timezone. Updating this too frequently or with unrealistic times may impact merchant performance ratings. Update the estimated ready time for a GrabFood order

Example Prompts for GrabFood Partner in AutoGen

Ready-to-use prompts you can give your AutoGen agent to start working with GrabFood Partner immediately.

"Show me all my GrabFood orders for today."

"Accept order GF-48921 and mark order GF-48915 as ready."

"Check my store status and pause it if it's currently open."

"Update the price of my Nasi Goreng to 25000 IDR and mark Fried Rice as unavailable."

Troubleshooting GrabFood Partner MCP Server with AutoGen

Common issues when connecting GrabFood Partner to AutoGen through the Vinkius, and how to resolve them.

McpWorkbench not found

Install: pip install "autogen-ext[mcp]"

GrabFood Partner + AutoGen FAQ

Common questions about integrating GrabFood Partner MCP Server with AutoGen.

How does AutoGen connect to MCP servers?

Create an MCP tool adapter and assign it to one or more agents in the group chat. AutoGen agents can then call GrabFood Partner tools during their conversation turns.

Can different agents have different MCP tool access?

Yes. AutoGen's role-based architecture lets you assign specific MCP tools to specific agents, so a querying agent has different capabilities than a reviewing agent.