Skip to main content
Glama
Carrefour Drive MCP

Carrefour Drive MCP

Carrefour Drive MCP — grocery shopping for your AI agent

MCP server for Carrefour Drive (carrefour.fr). Let Claude, Cursor, or any Model Context Protocol client search the French grocery catalogue, build a cart, pick a Drive pickup or delivery slot, read loyalty points and past receipts — on your own Carrefour account.

48 tools. 43 real carrefour.fr API endpoints described as JSON and run by a generic executor, plus 5 session-management tools. Adding an endpoint means dropping in a JSON file — no code.

"What did I buy last month?"            → get_loyalty_order_receipts
"Refill my usual weekly groceries."     → get_frequent_purchases + add_item_to_cart
"Cheapest organic pasta under 2 €?"     → search_products
"Book the Saturday morning Drive slot." → get_delivery_timeslots + select_cart_delivery_slot
  • Standalone — no spectral binary, no external gateway, no API key. Clone, build, run.

  • Cloudflare-proof — every call is issued from a real Chromium page, because nothing else gets a 200.

  • Stays logged in — you log in once in a browser window; the server renews the session by itself through the OAuth2 SSO loop.


Table of contents


Related MCP server: grocery-mcp

Install

Nothing to clone. Node.js 20+ is the only prerequisite (native fetch, FormData, node:test).

npx -y github:maximeallanic/CarrefourDriveMCP

That single command fetches, builds and starts the server on stdio — the first run also downloads the Chromium it uses as HTTP transport. Most of the time you never type it yourself: you put it in your MCP client config (next section) and the client runs it for you.

Prefer it installed once, globally?

npm install -g github:maximeallanic/CarrefourDriveMCP
carrefour-drive-mcp

Your session, browser profile and logs live in ~/.carrefour-drive-mcp ($XDG_DATA_HOME/carrefour-drive-mcp when set), so upgrades never log you out. Override with CARREFOUR_DATA_DIR.

git clone https://github.com/maximeallanic/CarrefourDriveMCP.git
cd CarrefourDriveMCP
npm install     # builds, and downloads the Chromium transport
node dist/index.js

A source checkout keeps its data in the repo's own data/ directory.

Connect it to your agent

Claude Code

claude mcp add carrefour-drive -- npx -y github:maximeallanic/CarrefourDriveMCP

Then, in any session:

> Log me in to Carrefour        (runs carrefour_browser_login)
> Add 2 L of semi-skimmed milk to my Drive cart

Claude Desktop

Edit claude_desktop_config.json:

  • macOS — ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows — %APPDATA%\Claude\claude_desktop_config.json

  • Linux — ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "carrefour-drive": {
      "command": "npx",
      "args": ["-y", "github:maximeallanic/CarrefourDriveMCP"]
    }
  }
}

Restart Claude Desktop; the Carrefour tools appear in the tools menu.

On Windows, use "command": "cmd" with "args": ["/c", "npx", "-y", "github:maximeallanic/CarrefourDriveMCP"].

Cursor, Windsurf, Zed, VS Code and other MCP clients

Any client that speaks MCP over stdio takes the same two fields:

{
  "command": "npx",
  "args": ["-y", "github:maximeallanic/CarrefourDriveMCP"]
}
  • Cursor — ~/.cursor/mcp.json (or .cursor/mcp.json in a project)

  • Windsurf — ~/.codeium/windsurf/mcp_config.json

  • VS Code / Copilot — .vscode/mcp.json, under "servers"

  • Zed — settings.json, under "context_servers"

Installed globally or cloned instead? Swap in {"command": "carrefour-drive-mcp"} or {"command": "node", "args": ["/absolute/path/to/dist/index.js"]}.

Already have cookies? Pass them in an "env" block instead of logging in: {"CARREFOUR_COOKIES": "…cookie header…"}.

Log in

carrefour.fr signs you in with cookies, behind a Cloudflare Turnstile captcha and an OTP. So the login is interactive, once:

  1. Ask your agent to run carrefour_browser_login.

  2. A browser window opens on the Carrefour login page. Type your email, password and the OTP code yourself.

  3. Don't close the window — the server detects the end of the OAuth loop, grabs the session cookies from memory and closes it for you.

From then on the session renews itself silently: the server replays the SSO authorize → callback redirect before authenticated calls, after a 401/403, and every 30 minutes as a keep-alive. You only log in again when the SSO cookie itself expires (24 h max, or 60 min idle) — the tools say so explicitly.

Check the state at any time with carrefour_session_status (verify: true makes a real call).

Session tool

What it does

carrefour_browser_login

open a window to sign in (captcha + OTP)

carrefour_session_status

stored cookies, browser profile, SSO time left

carrefour_refresh_session

force a renewal (rarely needed — it's automatic)

carrefour_set_cookies

import cookies manually (header, JSON map, or JSON array)

carrefour_clear_session

wipe the local session

For carrefour_set_cookies, only the JSON array format carries the cookie domain — it's the only one that can supply c4iamsecuretk, without which automatic renewal is impossible.

The cookie jar lives in <data dir>/sessions/cookies.json (0600) and is re-injected into the browser profile on every start.

Tool reference

Search & catalogue (no account needed)

Tool

Endpoint

Required params

search_products

GET /s

q

autocomplete_search

GET /autocomplete

q

get_products_by_gtins

POST /products

gtins

get_products_by_query

GET /products/query/{query_id}

query_id

get_product_reviews

GET /product/{ean}/reviews

ean

get_navigation_tree

GET /navigation

—

get_marketing_placements

POST /api/marketing/{placement}

placement, searchTerm, categories, productFilters

get_donation_products

GET /donation

—

get_chat_preprompts

POST ocb.carrefour.fr/preprompts

modes, count, navigationCurrentPageTitle, navigationCurrentPageType

get_eligible_drive_stores

GET /api/eligibility/drive

latitude, longitude, postalCode, city

Cart & checkout

Tool

Endpoint

Required params

get_cart

GET /api/cart

—

add_item_to_cart

PATCH /api/cart

ean, counter, basketServiceId, subBasketType

add_item_to_cart_by_ean

PATCH /api/cart/items

ean, basketServiceId, subBasketType

apply_promo_code_to_cart

POST /api/cart/promo_code

code, facilityServiceId, subBasketType

simulate_cart_for_store

GET /api/cart/simulate

storeRef

get_delivery_timeslots

GET /api/timeslots

facilityServiceId

select_cart_delivery_slot

PUT /api/cart/slot

slotRef, storeRef

validate_checkout_slot

POST /api/checkout/{basket_service_type}/validate/slot

basket_service_type, deviceFingerPrintId

validate_checkout_summary

POST /api/checkout/{basket_service_type}/validate/summary

basket_service_type, deviceFingerPrintId

get_checkout_recommendations

GET /api/checkout/recommendations/{facility_id}/{basket_service}

facility_id, basket_service

submit_checkout_payment ⚠️

POST /api/checkout/payment

checkout_type, device_fingerprint_id, payments

⚠️ submit_checkout_payment charges a real payment. Four of its parameters were captured as query string while their description suggests HTTP headers — check against a real trace before using it in production.

Account, orders & loyalty

Tool

Endpoint

Required params

get_orders

GET /api/user/orders

—

get_last_orders

GET /api/user/orders/last

—

get_frequent_purchases

GET /mon-compte/achats-frequents

—

get_loyalty_balance

GET /api/user/secured/loyalty/balance

—

get_loyalty_cards

GET /api/user/secured/loyalty/my-cards

—

get_loyalty_coupons_dashboard

GET /api/user/loyalty/coupons-dashboard

—

get_loyalty_coupon_collection

GET /api/user/loyalty/coupon-collection

—

get_loyalty_order_receipts

GET /api/user/secured/loyalty/orders/receipts

loyaltyCardNumber, loyaltyCardType

get_loyalty_order_receipt_details

GET /api/user/secured/loyalty/orders/receipt/{gln}/{date_key}/{receipt_number}

gln, date_key, receipt_number

get_advantage_codes

GET /api/advantage-code

—

get_vignettes_products

GET /api/user/products/vignettes-products

—

get_olympic_games_prime

GET /api/user/loyalty/olympic-games/prime

—

get_account_kpis

GET /api/user/my-account/kpis

codes

get_user_consents

GET /api/user/my-account/consents

—

get_favorite_store

GET /api/favoritestore

—

get_store_information_inserts

POST /api/information-insert/stores/{store_id}

store_id, insert_ids

get_homepage_returning_banner

GET /api/homepage/returningBanner

—

get_personalized_recommendations

GET /api/user/recommendation/cdp

—

get_product_recommendations

GET /api/recommendations

context

Shopping lists

Tool

Endpoint

Required params

get_shopping_lists

GET /api/shopping-lists

—

get_shopping_list

GET /api/shopping-lists-id/{list_id}

list_id

create_shopping_list

POST /api/shopping-lists/memo-list

title

Why a real browser

carrefour.fr sits behind a Cloudflare managed challenge that fingerprints the client. Measured from one IP, on the same day:

Client

GET /api/cart

fetch (undici)

403 cf-mitigated: challenge, on the very first request

curl

200 for a few calls, then 403

Chrome

200

No amount of header tweaking changes that: the only viable transport is a browser. And the requests must be issued from a page — Playwright's APIRequestContext uses a Node HTTP stack and gets blocked like fetch.

So the server keeps a persistent Chromium and runs every API call as a fetch inside a page parked on the target origin (one page per origin, because of CORS). It runs windowless, but not in standard headless mode:

Launch mode

Result

headless: true (headless shell)

403 — the UA announces HeadlessChrome

headless: false

200

channel: 'chromium' + masked UA + --disable-blink-features=AutomationControlled

200, navigator.webdriver is false

The last line is what ships.

How authentication works

Two distinct cookie systems:

Domain

Role

Lifetime

moncompte.carrefour.fr

ForgeRock SSO, cookie c4iamsecuretk

24 h max, dies after 60 min idle

www.carrefour.fr

store session (HttpOnly cookies)

short, renewable

Login is interactive because of two constraints: the form is behind a Cloudflare Turnstile captcha that refuses to validate in a CDP-driven browser, and c4iamsecuretk is a session cookie Chromium never writes to disk. So the window is a plain Chromium with a debug port open but nothing attached until login finishes; the server polls the tab over plain HTTP on /json/list (no CDP domain enabled, so no automation trace), attaches the moment the OAuth loop lands back on the store, and reads the cookies from memory.

Renewal afterwards is a plain navigation — Chromium follows the redirects and sets the cookies itself:

GET moncompte.carrefour.fr/iam/oauth2/CarrefourConnect/authorize?client_id=…&redirect_uri=https://www.carrefour.fr/login/check
  └─302─► www.carrefour.fr/login/check?code=…   (the BFF exchanges the code)
      └─302─► www.carrefour.fr/                  (fresh session cookies)

How the executor works

tools/*.json ──► loader (validation) ──► params (JSON Schema ➜ zod) ──► MCP tools/list
                                     └─► resolve ($param ➜ URL/query/headers/body)
                                              └─► http.service (cookies + rate limit + fetch)

Every file in tools/ is self-describing:

{
  "name": "add_item_to_cart",
  "parameters": { "type": "object", "properties": { … }, "required": [ … ] },
  "request": {
    "method": "PATCH",
    "url": "https://www.carrefour.fr/api/cart",
    "headers": { … },
    "query": {},
    "body": { "items": [ { "ean": { "$param": "ean" }, … } ] },
    "content_type": "application/json"
  },
  "requires_auth": true
}

The engine (src/spec/):

  • recursively substitutes {"$param": "name"} nodes in headers, query and body, preserving the original type (number, boolean, array);

  • drops placeholders with no argument, so optional params vanish from the request instead of being sent as null;

  • fills URL segments {basket_service_type}, {store_id}, … with encoding, failing with a clear message when a required segment is missing;

  • serialises arrays as repeated query keys (codes[]=14&codes[]=15);

  • encodes the body per content_type: JSON, x-www-form-urlencoded or multipart/form-data (boundary left to fetch);

  • applies a sliding rate limit with jitter, plus browser headers.

Adding an endpoint = dropping a new JSON file into tools/. No code to write.

Configuration

See .env.example. Main variables:

Variable

Default

Role

CARREFOUR_COOKIES

—

session cookies (header, JSON map or JSON array)

CARREFOUR_COOKIE_FILE

—

path to a JSON cookie export

CARREFOUR_DATA_DIR

~/.carrefour-drive-mcp (repo data/ from source)

root of everything written below

CARREFOUR_SESSION_FILE

<data>/sessions/cookies.json

persisted cookie jar

CARREFOUR_BROWSER_PROFILE

<data>/browser-profile

persistent Chromium profile

CARREFOUR_KEEPALIVE_MINUTES

30

SSO keep-alive period; 0 disables

CARREFOUR_OAUTH_CLIENT_ID

carrefour_onecarrefour_web

OAuth2 client used for refresh

CARREFOUR_OAUTH_REDIRECT_URI

https://www.carrefour.fr/login/check

BFF callback

CARREFOUR_OAUTH_SCOPE

openid iam

requested scopes

CARREFOUR_TOOLS_DIR

<project>/tools

JSON tool definitions directory

CARREFOUR_MAX_RESPONSE_CHARS

60000

truncation of large responses

REQUEST_TIMEOUT_MS

30000

HTTP timeout

RATE_LIMIT_REQUESTS / RATE_LIMIT_WINDOW_MS

10 / 60000

rate-limit window

MIN_DELAY_MS / MAX_DELAY_MS

100 / 500

jitter between requests

LOG_LEVEL, CARREFOUR_LOG_DIR

info, <data>

winston logs (files + stderr, never stdout)

Verify the install

From a source checkout:

npm run build     # tsc
npm test          # build + unit tests (node:test)
npm run smoke     # build + real MCP stdio handshake + tools/list
npm run verify    # all three

Tests cover $param substitution, URL segments, arrays in query strings, the three body encodings, and cookie-jar handling. The smoke test actually boots the server, performs the JSON-RPC handshake and lists the tools.

Network calls to carrefour.fr are not tested automatically — they need a real account and valid cookies.

FAQ

Do I need an API key? No. Carrefour has no public API; this server drives the same private endpoints the website uses, with your own session.

Does it work outside France? The catalogue and stores are French (carrefour.fr). Cloudflare may be stricter from some IPs.

Is my password stored? No. You type it in a browser window; only cookies are persisted, in ~/.carrefour-drive-mcp/sessions/cookies.json with 0600 permissions. No credential lives in this repo, and data/ and .env are gitignored.

Can it place a real order? Yes — submit_checkout_payment charges a real payment. Treat it accordingly.

Can I add endpoints? Drop a JSON file in tools/. See How the executor works.

Which clients are supported? Anything speaking MCP over stdio: Claude Code, Claude Desktop, Cursor, Windsurf, VS Code / Copilot, Zed, Continue, custom agents using the MCP SDK.

Disclaimer

Unofficial project, not affiliated with, endorsed by, or supported by Carrefour. For personal and educational use on your own account. Respect Carrefour's terms of service and rate-limit yourself accordingly.

License

MIT © Maxime Allanic


Keywords: Carrefour MCP server · Carrefour Drive API · Model Context Protocol grocery · Claude Desktop MCP · Claude Code MCP server · Cursor MCP · French grocery shopping AI agent · courses en ligne · drive · liste de courses · fidélité Carrefour · MCP shopping cart automation.

Available Tools

48 tools
add_item_to_cartA

Adds or updates a product item in the authenticated user's cart on Carrefour France. Allows specifying the product EAN, desired quantity, the basket service (store/drive), and the sub-basket type (e.g. drive click-and-collect). Also accepts a tracking context to indicate the page type and ID from which the action was triggered. Returns updated cart totals and summary. (requires an authenticated Carrefour session)

Inputs: ean (required), counter (required), subBasketType (required), basketServiceId (required), +2 more.

add_item_to_cart_by_eanA

Adds a product to the authenticated user's cart on Carrefour France using the product EAN, a basket service ID, and a sub-basket type (e.g. drive click-and-collect). Also accepts a tracking context to indicate the page type and page ID from which the action was triggered. Returns updated cart totals and summary. (requires an authenticated Carrefour session)

Inputs: ean (required), subBasketType (required), basketServiceId (required), pageId, +1 more.

apply_promo_code_to_cartA

Applies a promotional/discount code to the authenticated user's cart on Carrefour France. Associates the promo code with a specific facility/store service and sub-basket type (e.g. drive click-and-collect). Returns a success confirmation or an error if the code is invalid or cannot be applied. (requires an authenticated Carrefour session)

Inputs: code (required), subBasketType (required), facilityServiceId (required).

carrefour_browser_loginA

Opens a browser window on the server profile so you can sign in to carrefour.fr. Finish the captcha and the emailed OTP, then close the window: the session — including the IAM SSO cookie that lets the server renew itself — stays in the profile. The login cannot be automated: Cloudflare Turnstile refuses to validate in a driven browser.

Inputs: no named parameters.

carrefour_clear_sessionA

Delete the locally stored Carrefour cookies.

Inputs: no named parameters.

carrefour_refresh_sessionA

Force a renewal of the www.carrefour.fr session from the stored IAM SSO cookie. Rarely needed by hand: authenticated requests already refresh and retry on their own.

Inputs: no named parameters.

carrefour_session_statusA

Report whether a Carrefour session is stored locally, and optionally verify it against the site.

Inputs: verify.

carrefour_set_cookiesA

Store your www.carrefour.fr session cookies so the other tools can act on your account. Accepts a raw cookie header ("a=1; b=2"), a JSON map, or a JSON array export (Playwright / EditThisCookie / DevTools). Get them from DevTools (F12) > Application > Cookies > https://www.carrefour.fr.

Inputs: cookies (required).

create_shopping_listA

Creates a new shopping list (memo-list type) for the authenticated user on Carrefour France. Accepts a title for the new list and returns the created list details including its ID, type, slug, item count, last updated date, and EANs. (requires an authenticated Carrefour session)

Inputs: title (required).

get_account_kpisA

Retrieves loyalty and financial KPI metrics for the authenticated user's account on Carrefour France. Each KPI is identified by a numeric code and returns a value (e.g. cumulative loyalty rewards earned in-store or online since the start of the current year). Useful for displaying account performance indicators on the loyalty/fidelity dashboard. Known codes include: 14 (cumulative in-store loyalty card rewards since the start of the year), 15 (cumulative drive/e-commerce and in-store loyalty discounts since the start of the year, excluding delivery fee discounts), 16 (cumulative e-commerce individual rewards since the start of the year, excluding delivery fee rewards). (requires an authenticated Carrefour session)

Inputs: codes (required).

get_advantage_codesA

Retrieves the advantage/promo codes available to the authenticated user on Carrefour France. Returns a list of advantage codes with details such as code value, validity start/end dates, reward amount, reward type, label description (e.g. immediate discount on a minimum purchase), whether it is for new customers only, validity slot, and terms and conditions. (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_cartA

Retrieves the current shopping cart contents and summary for the authenticated user on Carrefour France. Returns cart totals (amounts, discounts, loyalty points, delivery fees), marketplace sub-baskets, additional orders, preorders, and relevant API endpoints. Optionally forces a refresh of cart data. (requires an authenticated Carrefour session)

Inputs: refresh.

get_chat_prepromptsA

Retrieves contextual and/or generic pre-suggested questions/prompts for the Carrefour AI chat assistant (OCB), based on the user's current navigation context (page type and title). For product detail pages, a product GTIN can also be provided. Returns contextual questions relevant to the current page (e.g. recipe suggestions for a search on 'tomato') and generic questions (e.g. recipe ideas, shopping list generation, product recommendations). Useful for populating chat suggestion chips on search results or product pages.

Inputs: count (required), modes (required), navigationCurrentPageType (required), navigationCurrentPageTitle (required), +1 more.

get_checkout_recommendationsA

Retrieves product recommendations during checkout on Carrefour France for a specific facility/store and basket service type. Returns recommendation zones such as frequent purchases, personalized recommendations, and current promotions, each with a list of products and delivery type. Useful for displaying cross-sell or upsell suggestions to the user at checkout. (requires an authenticated Carrefour session)

Inputs: facility_id (required), basket_service (required).

get_delivery_timeslotsA

Retrieves available delivery or drive time slots for a specific facility/store service on Carrefour France. Returns a list of days with available time slot cells, indicating availability, dates, and collaborative delivery type. Useful for letting the user pick a delivery or click-and-collect time window. (requires an authenticated Carrefour session)

Inputs: facilityServiceId (required).

get_donation_productsA

Retrieves the list of donation products (charitable associations) available on Carrefour France. Returns a list of donation items with their EAN, title, brand, slug, category, images, and other product attributes. Useful for displaying available charities/associations that users can donate to during checkout.

Inputs: no named parameters.

get_eligible_drive_storesA

Retrieves a paginated list of Carrefour drive stores eligible for ordering near a given location on Carrefour France. Returns store details such as ID, name, reference, distance from the provided coordinates, banner, address, format, order type, and opening patterns. Useful for finding nearby drive/click-and-collect stores available for a specific city or postal code.

Inputs: city (required), latitude (required), longitude (required), postalCode (required), +2 more.

get_favorite_storeA

Retrieves the authenticated user's favorite/preferred store on Carrefour France. Returns store details such as store ID, reference, GLN, name, postal code, store format, drive type, and available service modes (drive, home delivery, express delivery, click-and-collect, etc.). (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_frequent_purchasesA

Retrieves the authenticated user's frequently purchased products on Carrefour France. Returns a paginated list of products the user buys regularly, with product details (EAN, title, brand, category, images, links), facets for filtering (promotions, Carrefour brands, etc.), and pagination metadata. Optionally includes unavailable products. (requires an authenticated Carrefour session)

Inputs: page, displayUnavailable.

get_homepage_returning_bannerA

Retrieves the returning user banner for the Carrefour France homepage. Returns a list of personalized product recommendations (with product ID, name, image URL, and optional highlight label such as 'promotion') tailored for returning users. Optionally limits the number of recommendations returned. (requires an authenticated Carrefour session)

Inputs: limit.

get_last_ordersA

Retrieves the most recent orders for the authenticated user on Carrefour France. Returns a list of the user's last orders with their details. (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_loyalty_balanceA

Retrieves the loyalty points balance for the authenticated user on Carrefour France. Returns the account bonus, last updated timestamp, available total points, and the date until which the points are valid. Useful for displaying the user's current loyalty points balance. (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_loyalty_cardsA

Retrieves the loyalty cards associated with the authenticated user's account on Carrefour France. Returns a list of loyalty cards with their card numbers and types (e.g. LOYALTY). Useful for displaying the user's registered loyalty/fidelity cards. (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_loyalty_coupon_collectionA

Retrieves the loyalty coupon collection for the authenticated user on Carrefour France. Returns a list of available coupons with details such as label, discount amount, discount unit, validity/expiration dates, product packaging description, image URL, category, and availability status. Also returns facet metadata for filtering by category. (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_loyalty_coupons_dashboardA

Retrieves the loyalty coupons dashboard summary for the authenticated user on Carrefour France. Returns the number of available coupons, total available coupon amount (in euros), and number of coupons already added to the cart. Useful for displaying a quick overview of the user's loyalty coupon status. (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_loyalty_order_receipt_detailsA

Retrieves the detailed receipt for a specific in-store purchase associated with the authenticated user's loyalty card on Carrefour France. Returns receipt details such as store name, transaction date, total paid amount, discounts, receipt number, barcode, and links to invoice/card receipt. The receipt is identified by the store GLN, date key, and receipt number. (requires an authenticated Carrefour session)

Inputs: gln (required), date_key (required), receipt_number (required).

get_loyalty_order_receiptsA

Retrieves the in-store purchase receipts associated with the authenticated user's loyalty card on Carrefour France. Returns a paginated list of receipts with details such as transaction date, store name, receipt number, total paid amount, and receipt label. Supports scrolling through results using a scroll paging token and scroll hash. Useful for displaying the user's in-store purchase history linked to their loyalty card. (requires an authenticated Carrefour session)

Inputs: loyaltyCardType (required), loyaltyCardNumber (required), scrollHash, scrollPaging.

get_marketing_placementsA

Retrieves marketing/advertising placements (e.g. sponsored products, banners) for a specific placement context on Carrefour France. The placement context is determined by the URL path segment (e.g. 'home', 'home_food', 'search', 'search_cross_sell', 'search_panel', 'pdp', 'pdp_cross_sell', 'category', 'category_cross_sell', 'basket', 'checkout'). Returns a list of ad placements with product details, beacons, and positioning information.

Inputs: placement (required), categories (required), searchTerm (required), productFilters (required).

get_navigation_treeA

Retrieves the full navigation/category tree for the Carrefour France website. Returns a hierarchical tree of categories (rayons) and redirections, including category names, codes, IDs, types, business types, slugs, picto URLs, and child categories. Also indicates whether promotions are currently active. Useful for building navigation menus or browsing the category hierarchy.

Inputs: no named parameters.

get_olympic_games_primeA

Retrieves the authenticated user's Olympic Games Prime loyalty account information on Carrefour France. Returns the account balance, whether the user has an associated sports club, the club name, and a link to the Olympic Games Prime website. Useful for displaying the user's Olympic Games loyalty subscription and club association status. (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_ordersA

Retrieves the authenticated user's order history on Carrefour France. Returns a paginated list of orders with details such as order number, service type, date, total amount, order status, store information, delivery slot, payment info, and available action links (cancel, refund, change slot, etc.). Supports filtering by date range (startDate/endDate), limiting the number of results (scrollSize), and paginating through results using a scroll hash and paging token. (requires an authenticated Carrefour session)

Inputs: endDate, startDate, scrollHash, scrollSize, +1 more.

get_personalized_recommendationsA

Retrieves personalized product recommendations for the authenticated user on Carrefour France, based on their CDP (Customer Data Platform) profile. Returns a wording block (image, text, title, color) and a list of recommended products tailored to the user's preferences (e.g. organic promotions, personalized deals). (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_product_recommendationsA

Retrieves product recommendations for a given page context on Carrefour France. On product detail pages (context=pdp), returns recommendation zones such as 'Customers also bought' and 'You might also like', based on the product EAN, price, categories, and facility service. On product listing pages (context=plp), returns recommendations based on categories. Returns a list of recommendation zones, each with a label and a list of recommended products. (requires an authenticated Carrefour session)

Inputs: context (required), price, category, scenario, +5 more.

get_product_reviewsA

Retrieves customer reviews for a specific product on Carrefour France, identified by its EAN/GTIN. Returns the total review count and a paginated list of reviews. Supports sorting by field and order, and limiting the number of reviews returned.

Inputs: ean (required), limit, sortField, sortOrder.

get_products_by_gtinsA

Retrieves product details for a list of GTINs (barcodes/EANs) from Carrefour France, optionally scoped to a specific facility/store service. Returns product details including EAN, title, brand, category, images, business type, and links for each matching product. Useful for bulk product lookups by barcode.

Inputs: gtins (required), facilityServiceId.

get_products_by_queryA

Retrieves a list of products from Carrefour France based on a predefined query identifier. Returns product details including EAN, title, brand, category, images, and links. Useful for fetching curated product lists (e.g. bestsellers, promotions, themed selections) identified by a query ID. (requires an authenticated Carrefour session)

Inputs: query_id (required), limit.

get_shopping_listA

Retrieves the details of a specific shopping list for the authenticated user on Carrefour France, identified by its unique list ID. Returns the list reference, title, type (e.g. MTB for in-store memo list), item count, categories, and memos/items. (requires an authenticated Carrefour session)

Inputs: list_id (required).

get_shopping_listsB

Retrieves all shopping lists for the authenticated user on Carrefour France. Returns a list of shopping lists with details such as list ID, title, type (e.g. standard, in-store), item count, slug, last updated date, and EANs of items in the list. (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_store_information_insertsA

Retrieves store-specific information inserts (e.g. banners, notices, messages) for a given store and a set of placement identifiers on Carrefour France. Useful for displaying contextual informational content at specific locations during checkout (e.g. top of checkout, checkout summary, checkout slot selection, checkout payment). Returns a list of information insert items for the requested placements. (requires an authenticated Carrefour session)

Inputs: store_id (required), insert_ids (required).

get_user_consentsA

Retrieves the marketing and communication consent preferences for the authenticated user on Carrefour France. Returns consent flags for various communication channels (email, SMS, WhatsApp, Instagram, Messenger) and partner/marketplace marketing preferences. (requires an authenticated Carrefour session)

Inputs: no named parameters.

get_vignettes_productsB

Retrieves the authenticated user's vignette products on Carrefour France. Returns a list of products associated with promotional vignettes/stickers collected by the user. Useful for displaying the user's vignette-based promotions or collectible product labels. (requires an authenticated Carrefour session)

Inputs: no named parameters.

search_productsA

Searches for products on Carrefour France using a text query. Returns a paginated list of products matching the query, along with pagination metadata, facets for filtering (promotions, Carrefour brands, categories, etc.), total result count, and navigation links. Supports pagination via the page parameter.

Inputs: q (required), page.

select_cart_delivery_slotA

Selects a delivery or drive time slot for the authenticated user's cart on Carrefour France. Associates the cart with a specific time slot at a given store. Returns the confirmed slot details including title, date/time range, cutoff time, slot reference, and expiration time in minutes. (requires an authenticated Carrefour session)

Inputs: slotRef (required), storeRef (required).

simulate_cart_for_storeA

Simulates the current shopping cart against a specific store on Carrefour France to check product availability. Returns the count of unavailable products and their GTINs (barcodes) for the given store reference. Useful for determining which cart items cannot be fulfilled at a particular store before placing an order. (requires an authenticated Carrefour session)

Inputs: storeRef (required).

submit_checkout_paymentA

Submits payment method selection for the authenticated user's checkout on Carrefour France. Sends the chosen payment methods (e.g. credit card by saved card ID, loyalty card with a specific amount) for a given basket service type (e.g. 'driveclcv' for drive click-and-collect). Returns the total and remaining amounts, available payment methods with provider tokens/URLs (Apple Pay, CB credit card, card pass, etc.), saved payment methods, and the payment group. Useful for initiating the payment step during checkout. (requires an authenticated Carrefour session)

Inputs: payments (required), checkout_type (required), device_fingerprint_id (required), apple_pay, +3 more.

validate_checkout_slotA

Validates the checkout slot step for a specific basket service type (e.g. 'driveclcv' for drive click-and-collect) on Carrefour France. Submits a device fingerprint ID and returns the current cart state, checkout step, store context, workflow steps, warnings, and available checkout links (payment, on-site payment, device fingerprint generator). Useful for confirming the slot selection step before proceeding to the payment step. (requires an authenticated Carrefour session)

Inputs: basket_service_type (required), deviceFingerPrintId (required).

validate_checkout_summaryA

Validates the checkout summary for a specific basket service type (e.g. 'driveclcv' for drive click-and-collect) on Carrefour France. Submits a device fingerprint ID and returns the current cart state, checkout step, store context, workflow steps, warnings, and available checkout links (payment, on-site payment, device fingerprint generator). Useful for initiating or confirming the checkout summary step before proceeding to payment. (requires an authenticated Carrefour session)

Inputs: basket_service_type (required), deviceFingerPrintId (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 48 tools

    Disambiguation2/5

    Several tool pairs have unclear boundaries, most notably add_item_to_cart and add_item_to_cart_by_ean, which both accept an EAN and the same cart context arguments. validate_checkout_slot and validate_checkout_summary have near-identical returned payloads, and get_orders/get_last_orders plus multiple recommendation tools add further overlap.

    Naming Consistency4/5

    The overall verb_noun snake_case pattern is consistent and readable, with get_*, crete_*, search_*, and validate_* tools. Deviations include the carrefour_ prefix applied only to session tools and inconsistent coupon/coupons singular/plural naming.

    Tool Count2/5

    At 48 tools, this is far beyond the 25+ threshold and places a heavy selection burden on the agent. Even for a broad e-commerce and loyalty API, the surface feels over-sized compared with more focused MCP servers.

    Completeness3/5

    The set covers search, product data, cart, checkout, orders, loyalty, stores, and shopping lists, but has noticeable lifecycle gaps: cart items can be added/updated but not removed, and shopping lists can be created and fetched but not updated or deleted. The checkout flow also lacks an explicit final order-confirmation tool, so some workflows may hit dead ends.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that connects Carrefour Drive to Claude and other MCP clients, enabling product search with real prices, nutriscore, availability, and natural language cart management.
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server for grocery-related web automation using Playwright, enabling AI assistants to interact with grocery websites.
      ISC
    • A
      license
      Not graded
      quality
      C
      maintenance
      Unofficial MCP server and CLI for controlling Carrefour Drive on carrefour.fr through a persistent Camoufox browser profile, enabling store/session checks, product search and inspection, cart reading, and cart additions without placing orders or making payments.
      MIT