100+ integrations are ready to connect to your AI.Connect your first MCP

Redo MCP server for your AI

Pull the returns queue, approve or reject what's waiting, process refunds and exchanges, ingest orders and fulfillments, and watch inbound shipments land at the warehouse.

PopMCPRedo

List returns from the past week that are still open and what's in each one

Supported Redo tools

Every returns, orders, inventory, customer, webhook and coverage call PopMCP exposes, plus the return and shipment events it can watch.

redo_create_return

Create a return for specific line items of an existing order.

redo_create_return_comment

Add a comment to a return.

redo_get_return

Get one return by its Redo return id.

redo_get_return_status

Get just the current status of a return by its id.

redo_list_return_comments

List the internal comments/timeline notes on a return.

redo_list_return_tags

List the store's return tags (the labels merchants apply to returns to organize them).

redo_list_returns

List this store's returns, most-recent-first.

redo_process_return

BETA — process a return to actually trigger its outcome (issue the refund / store credit / exchange) for the chosen products.

redo_update_return_status

Set a return's status.

redo_create_webhook

Create OR update a webhook subscription (upserts by externalId).

redo_delete_webhook

Delete a webhook subscription by id (path `webhookId`).

redo_list_inbound_shipments

List inbound shipments (returns/transfers heading to a warehouse — in transit or received).

redo_list_inventory_items

List in-stock inventory items (on-hand quantity > 0).

redo_list_inventory_levels

List aggregate product quantities by location (the inventory 'level' per product/variant at a location).

redo_list_webhooks

List the store's registered webhooks.

redo_create_fulfillment

Create a fulfillment on an order (path `orderId`) with the shipped line items and optional tracking.

redo_create_order

Create (ingest) an order in Redo so returns/exchanges can be made against it — typically for stores not on a natively-synced platform.

redo_get_order

Get one order including all of its fulfillments.

redo_update_fulfillment_status

Post a shipment-status / tracking event for a fulfillment (paths `orderId` + `fulfillmentId`).

redo_get_customer

Look up a customer by email (required query param `email`).

redo_update_customer_subscriptions

Update a customer's email/SMS marketing (and SMS transactional) subscription status.

redo_upsert_customer

Create or update a customer.

redo_create_event

Record a single custom event (a merchant-defined event Redo can use in automations/segmentation).

redo_get_coverage_products

Compute the available Redo coverage products (package protection / returns coverage upsell) for a given cart.

redo_list_invoices

List the store's Redo billing invoices.

redo_delete_return_tag

Delete a return tag by name (path `name`, case-sensitive, URL-encoded).

redo_import_returns

Import returns that were created OUTSIDE Redo (e.g.

redo_upsert_return_tag

Create, rename, or recolor a return tag.

redo_get_inbound_shipment

Get one inbound shipment by id (path `inboundShipmentId`), including its purchase orders, transfer orders, files, and any receiving discrepancies.

redo_get_inventory_item

Get one inventory item by its id (path `inventoryItemId`).

redo_get_inventory_level

Get one aggregate inventory level by its id (path `inventoryLevelId`).

redo_get_webhook

Get one webhook by id.

redo_replay_webhook

Replay past events to a webhook (path `webhookId`) — e.g.

redo_update_webhook

Update a webhook's callback (path `webhookId`).

redo_delete_order

Delete an order from Redo by id.

redo_get_customer_portal_url

Navigate to the Redo customer self-service portal (where shoppers start returns/exchanges).

redo_bulk_create_events

Record up to 100 custom events in one call.

redo_create_storefront_event

Ingest a storefront browsing/checkout event using the Shopify web-pixel event schema (for attribution/analytics).

redo_get_checkout_buttons_ui

Get the rendered HTML/CSS for Redo's returns-coverage checkout buttons (the toggle shown at checkout).

redo_get_coverage_info_url

Navigate to the customer-facing coverage info page.

redo_get_invoice_csv

Download one invoice's line items as CSV (path `invoiceId`).

redo_get_pending_invoice_csv

Download the CURRENT (not-yet-finalized) invoice's accrued line items as CSV — the running charges since the last invoice.

redo_bulk_upload_products

Bulk create/update product families and their variants in Redo (so they can be selected as exchange items, etc.).

redo_get_merchant_admin_url

Navigate to the Redo merchant admin for this store.

Connect Redo to your AI

Credentials off one Redo screen, then an endpoint your client signs into. Nothing to deploy, and nothing to install.

Paste your Store ID and API Secret, both from the same screen: Redo dashboard → Settings → Developer. No OAuth app, client secret or redirect URL. The secret is scoped to one store, so the MCP is locked to that store.

Store ID6691603a8460182719ab678e
API Secret••••••••••••3f7a
ConnectionVerified

Then just ask for the work

  • List returns from the past week that are still open and what's in each one

    • list_returns
    • get_return_status
    • get_return
  • Approve the three flagged returns from yesterday and leave a note on each

    • list_returns
    • update_return_status
    • create_return_comment
  • Create a return for the damaged mug on order 10482 and comment why

    • get_order
    • create_return
    • create_return_comment
  • How much stock came back into the LA warehouse from returns this month

    • list_inbound_shipments
    • get_inbound_shipment
    • list_inventory_levels

Use Redo from the assistant you already open

One hosted endpoint, registered once per client. The same tools and the same permissions, whichever window the request comes from.

Claude DesktopCustom connector

Add the PopMCP URL under Settings → Connectors and the tools appear in every chat.

Claude WebCustom connector

The same endpoint, registered in the browser. Nothing to install on the machine you are working from.

ChatGPTCustom connector

Register PopMCP as a custom connector, then let ChatGPT read and update the account.

CodexDesktop & CLI

Wire the endpoint into Codex or the Codex CLI when a task needs live business context, not a fixture.

OpenCodeCoding agent

Register the remote MCP server in OpenCode's config for terminal-first and scripted agent runs.

ZCodeDesktop app

Add PopMCP as an MCP server in Z.ai's desktop app and work the account from the same window.

Redo MCP server questions

What teams ask before putting Redo behind an AI client.

Do I need to set up an OAuth app to connect Redo?

No. The connect form asks for two values, Store ID and API Secret, and both come from the same screen in the Redo dashboard under Settings → Developer. There is no OAuth app, client secret or redirect URL to register. The secret is scoped to a single store, so the connection is locked to that store.

How many Redo operations can the agent call?

44 operations across 10 API modules, split 23 read and 21 write. 25 load into your AI client by default and the rest stay searchable, so Redo doesn't crowd out the other servers in your tool list. Returns is the largest module with 12 operations, followed by Webhooks, Inventory and Orders.

Can the agent actually issue a refund, store credit or exchange?

Yes. process_return triggers the real outcome for the products you pick, and Redo marks that operation BETA. update_return_status only moves a return's status; it doesn't move money. Read-only mode blocks the money-moving call outright, and approval-required-for-writes holds it for a person to confirm first.

Does this work if my store isn't on a natively-synced platform?

Yes. create_order ingests an order into Redo so returns and exchanges can be made against it, which is the usual path for stores Redo doesn't sync natively. import_returns brings across returns that were created outside Redo. Storefront browsing and checkout events go in through create_storefront_event, which expects the Shopify web-pixel event schema.

Can it see stock and warehouse receiving, or only returns?

Both. list_inventory_items covers in-stock items with on-hand quantity above zero, and list_inventory_levels gives the aggregate quantity per product or variant at each location. On the receiving side, list_inbound_shipments covers returns and transfers heading to a warehouse, and get_inbound_shipment adds that shipment's purchase orders, transfer orders, files and any receiving discrepancies.

What API quirks should I know before wiring this up?

get_customer looks a customer up by email, and email is a required query parameter, so you need the address on hand. delete_return_tag takes the tag name in the path, case-sensitive and URL-encoded, so VIP and vip are not the same tag. create_webhook upserts by externalId, which means reusing an externalId updates the existing subscription instead of creating a duplicate.

Do I have to run or host the Redo MCP server myself?

No. PopMCP hosts it and gives you a Streamable HTTP MCP URL. There is nothing to deploy, no callback URL to register, and no infrastructure to keep running or patch.

Which AI clients can use this MCP server?

Any client that supports a remote Streamable HTTP MCP server — Claude Desktop, Claude Web, ChatGPT custom connectors, Codex and the Codex CLI, OpenCode and Z.ai's ZCode, as well as editors such as Cursor, Windsurf and Zed. Your client signs in to PopMCP with OAuth; the provider credential never leaves the server.

Why do only 25 of the 44 tools load by default?

Loading 44 tool definitions into every conversation burns context before the work starts. PopMCP loads a curated 25-tool set covering the everyday workflows and keeps the rest searchable, so your AI pulls a specialist tool only when a task needs it. You can switch a connection to the full catalog at any time.

What is the difference between a tool and a trigger?

A tool is something your AI calls — there are 44 here. A trigger is something PopMCP watches for you: 12 Redo events that can start work on the PopMCP side. Triggers never enter your AI client's context, and none of them ask you to paste a callback URL into Redo.

Connect Redo to your AI in minutes

Launch a hosted MCP endpoint for Redo, keep tool access under control, and start testing real workflow prompts right away.

Connect your first MCP