- Brand
- ABConvert
- Category
- Commerce
- Primary Subcategory
- Ecommerce Operations Platforms
Integration details
Description
ABConvert helps Shopify merchants inspect, create, preview, manage, and analyze A/B experiments using their connected ABConvert account. Explore experiments and products, review experiment results and traffic breakdowns, and create draft price tests. Supported experiment types and actions depend on the tools available to the connected store. New experiments are saved as drafts unless you explicitly request a launch. Results are based on the connected store's available data; small samples and missing metrics do not establish a winner. Access is limited to the authorized store and permissions. An installed ABConvert app and a store connection are required.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Ecommerce Operations Platforms
- Secondary Subcategories
- None listed
- Brand
- ABConvert
- Access
- Account required
- First tracked
- 2026-11-20
- Tool count
- 58
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen ABConvert suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for ABConvert
Get updates when ABConvert’s Discoverability Score or category rank changes.
Competing in ChatGPT Ecommerce Operations Platforms
View Category58 tools agents can invoke
Run the autopilot OrderAnalyzer on the merchant's shop: pulls last-60-days Order + AbandonedCheckout, returns AOV percentiles, a $5-banded subtotal histogram joined with abandonment counts, the inferred current free-shipping threshold, discount engagement metrics, and customer repeat ratio. Use this to inspect the input data a funnel-track recommender (Shipping/Price/Offer) would see, or to verify a recommender's output against the underlying numbers. Read-only.
analyze_orders
Duplicate an existing experiment into a new Draft. Use when the user says "clone that test", "run a follow-up like the hoodie test", "copy this experiment", "set up another one like that". Produces an exact copy as a draft (same products, groups, and settings) with a new id. The source experiment is unchanged, and the new draft receives no traffic until it is started. To make a variation (e.g. "the same test but at 5% off"), clone first, then rename with update_experiment and adjust pricing in the ABConvert admin. Only works on current (v5) experiments. Call start_experiment afterwards to launch the copy. A cloned checkout test gets new Block IDs, so its checkout blocks show only once the merchant places them again: put the copy in Preview with preview_experiment, then pass on the answer's `checkoutEditor` as create_checkout_test describes, one numbered list with each Block ID alone in a code block.
clone_experiment
Compare results across multiple tests at once using each result snapshot's server-published verdict and SRM status. Returns a per-test outcome (winner / loser / inconclusive / srm-broken / refreshing / no-data) plus headline summary and aggregate totals. Use it for questions such as "how did my tests last quarter perform", "which running tests are winning", or "are any tests broken". Filters mirror list_experiments and get_experiment_results scopes: inclusive shop-local date range, assignment/exposure sample basis, core/engagement metrics, product group, custom-event metric view, and independent custom-event population segment. A segment omits each test winner and adds the server post-treatment warning rather than making a rollout judgment. Internally fans out read-only summary GETs with bounded concurrency.
compare_experiments
Four inputs shape test quality and are best taken from what the merchant actually asked for rather than left to default: (1) `hypothesis` — what the test is expected to prove (e.g. "10% off lifts revenue per visitor"); (2) `experimentGoal` — the primary metric that defines success (revenue_per_visitor, conversion_rate, average_order_value); (3) `trafficAllocationPercent` — the share of visitors who enter the test (default 100); (4) `audienceTargeting` — an optional filter on who enters the test, relevant only when the request implies one ("test only on mobile", "US visitors only"). A test created with none of these set is valid but weak: no stated hypothesis, no primary metric, full traffic, and no audience filter. Naming: the ABConvert dashboard labels `audienceTargeting` "Audience" (who enters the test) and labels `forceAssignRules` "Targeting" (override the random split for specific visitors). They are separate features, so "audience" or "audience filter" is the accurate term for `audienceTargeting`. Launch behavior: `saveAsDraft` defaults to true and creates a draft that receives no traffic. Passing `saveAsDraft: false` launches immediately and changes what real customers see, so it reflects an explicit instruction to go live ("launch it immediately", "go live now", "skip the draft step") rather than a bare confirmation of the settings. A draft can be launched later with `start_experiment` or checked first with `preview_experiment`. --- Set up a checkout A/B test — change how delivery (shipping) methods and payment methods appear at checkout, and (Plus only) checkout UI content blocks. Use when the user says "hide express shipping at checkout", "rename Standard to Free Shipping", "move PayPal to the top", "test reordering payment methods", "hide Cash on Delivery for orders over $200". Each test group has `modifications`, each with a `kind` and `op`: `kind: "delivery"` or `"payment"` with `op: "hide"` (`methods: [names]`), `"rename"` (`renameRules: [{fromMatcher, from, toAction, to}]`), or `"reorder"` (`pinnedMethods: [{matcher, value}]`) — these work on all plans. `kind: "block"` adds checkout UI content (`blockType`, `props`) and is Shopify-Plus-only/advanced. Method names match the merchant's checkout labels (use the names the user gives). `kind: "post-purchase"` with `op: "offer"` adds a one-click offer on the page after payment, for "test a 15% off wax kit after checkout"; a test can change checkout and that page together, and a Control with no offer compares the offer against none. A block's optional `showWhen` shows it only for carts that match (products, collections, quantities, subtotal, subscription). The The Control test group is usually empty (unchanged checkout); other test groups need at least one checkout change. Test group percentages must sum to 100. This creates a draft by default. Call `start_experiment` to launch it. To change a checkout test that exists, use edit_checkout_test. BEFORE BUILDING: if a requested checkout benefit cannot be provided by a supported block, rule or tagged product deal, say which requirement is unsupported before previewing or creating. A checkout block alone does not grant an order discount or free shipping; do not promise either without a corresponding live store discount, shipping rate or supported rule. A tagged Custom product deal has one amount-off-products part, not a buy-quantity tier; offer the closest supported one-time product deal and state which tier requirement remains unmet after building. After creating a test, explicitly name any part of the request that the saved test does not implement. PREVIEW FIRST: before saving a checkout change, preview it with preview_checkout_test (`proposal` for a new test, `experimentId` and `changes` for one that exists) and show the merchant. Each preview carries every change not saved yet, not only the latest: when the merchant asks for another change, preview the whole revised list again. Save only once they approve, exactly the last list you previewed: create_checkout_test with the same proposal for a new test, edit_checkout_test with the same changes for one that exists. When the chat shows no preview, describe it in plain words from the answer's `blocks` and `rules`. If part of the request cannot be built, say exactly what is unsupported before building. Do not write copy promising it. After building, explicitly list any requested outcome that was not fulfilled, even when the rest was saved. BUILT-IN BLOCKS FIRST: when the merchant has not chosen a block type, check whether a built-in block type does what they asked, and use it when one does: the merchant can change it in the ABConvert admin form without an AI. Built-in types: heading (a title); banner (a message with a tone); trust-badge (reassurance rows such as secure checkout or free returns); benefit (selling points with icons); faq (questions shoppers tap to see the answer, such as shipping and returns); payment-icon (accepted payment brand icons); image (images, one or a carousel); button (link, email or call buttons); upsell-product-tile (products to add to the order); paid-add-on (paid services such as gift wrap, as checkboxes); custom-fields (shown to the merchant as Gift message: one question for the shopper, such as a gift checkbox and message, saved on the order); reviews (real reviews from the store's review app); rewards-progress (progress toward free shipping, a free gift or a discount); cart-control (lets shoppers change quantities and product variants, remove items, or switch an item to a subscription plan, under the cart lines); next-order-discount (shown to the merchant as Next-order discount: after payment, a discount code for the buyer's next order to copy, with up to 3 products to come back for; ABConvert creates the Shopify discount). On the Thank you and Order status pages (the thank-you-* and order-status-* placements) only heading, banner, button, benefit, image and next-order-discount blocks show, and next-order-discount shows only there. Here, a built-in block is a `kind: "block"` modification with that `blockType`. An explicit request for a Custom block takes precedence over the built-in suggestion. Build a Custom block when none fits, such as content that changes with each cart line, a message for subscription carts, or a layout no built-in type has, and tell the merchant which built-in type came closest and why it did not fit. PLACING BLOCKS: a checkout block shows at checkout only once the merchant adds its app block in Shopify's checkout editor. What to add is the answer's `checkoutEditor`, with `checkoutEditorUrl` and `blocks`, each with `block` (the app block to add), `placement` (where, such as "Before contact"), `summary` (what it shows, and in which test groups), for an ABConvert Checkout Block, `blockId`, and for a block on the Thank you or Order status page, its own `checkoutEditorUrl` and `pageStep`. Put the test in Preview before you give the steps: the checkout editor shows a block's content only for a test in Preview or running, and for a Draft it shows a warning that no test targets the Block ID. So when the test is a Draft and every Custom block in it is built, call preview_experiment with its ID, without asking: real shoppers are not assigned to a test in Preview. If it refuses, tell the merchant what to fix, from each finding's `fix` and `fixUrl` when it has them, and give the steps once it passes. Give the steps as one numbered list, whatever the number of blocks, with the entries in the answer's order (blocks that share a placement are added in that order; a Block ID several test groups share is added once): 1. Open the checkout editor: [Open checkout editor](<checkoutEditorUrl>) 2. Add an ABConvert Checkout Block at each placement below, and in each block's settings set Block ID to the one shown: **<placement>**: <summary> ``` <blockId> ``` 3. Save the checkout editor. Repeat the bold line and its code block under step 2 for each entry with a blockId, indented so the numbering holds. Put the Block ID alone in its code block, with nothing else on the line, so the merchant can copy it. An entry with no blockId (ABConvert Cart Control) gets its own step before the save: "Add the ABConvert Cart Control at <placement>. No Block ID needed." An entry with `pageStep` goes on the Thank you or the Order status page (its `pageStep` names which), which the answer lists after the Checkout page, Thank you first: give each page's entries their own steps after the save, "Open the <page> page: [Open checkout editor](<its checkoutEditorUrl>)", then "In the page menu at the top of the editor, choose <page>", then, for each, its `pageStep` (where in the editor to add the ABConvert Checkout Block) with the bold line and Block ID code block as in step 2, then save again. When every entry is on one such page, those are the whole list: step 1 opens that page and step 2 says to choose it in the page menu at the top of the editor. When no entry has a blockId, leave out step 2. When preview_experiment gave a `previewUrl`, give it after the list, for checking the test on the store once the editor is saved. Always show Block IDs: unlike other ids, the merchant types them into the checkout editor. STORE SETUP: an answer has `setup` only when the test uses a store setting that is not ready: the post-purchase page app (for a post-purchase offer) or the ABConvert checkout check (for a paid add-on with required text or a Custom block with Pay checks). Then show `setup.guide` to the merchant as it is, with no steps added or reworded, and when `setup.checkoutCheck.canTurnOn` is true, offer to turn the check on for them with turn_on_checkout_check. With no `setup`, say nothing about setup.
create_checkout_test
Four inputs shape test quality and are best taken from what the merchant actually asked for rather than left to default: (1) `hypothesis` — what the test is expected to prove (e.g. "10% off lifts revenue per visitor"); (2) `experimentGoal` — the primary metric that defines success (revenue_per_visitor, conversion_rate, average_order_value); (3) `trafficAllocationPercent` — the share of visitors who enter the test (default 100); (4) `audienceTargeting` — an optional filter on who enters the test, relevant only when the request implies one ("test only on mobile", "US visitors only"). A test created with none of these set is valid but weak: no stated hypothesis, no primary metric, full traffic, and no audience filter. Naming: the ABConvert dashboard labels `audienceTargeting` "Audience" (who enters the test) and labels `forceAssignRules` "Targeting" (override the random split for specific visitors). They are separate features, so "audience" or "audience filter" is the accurate term for `audienceTargeting`. Launch behavior: `saveAsDraft` defaults to true and creates a draft that receives no traffic. Passing `saveAsDraft: false` launches immediately and changes what real customers see, so it reflects an explicit instruction to go live ("launch it immediately", "go live now", "skip the draft step") rather than a bare confirmation of the settings. A draft can be launched later with `start_experiment` or checked first with `preview_experiment`. --- Set up an offer (discount) A/B test — measure whether a discount lifts revenue/conversion vs no offer or vs a different offer. Use when the user says "test a 15% off promo", "does free shipping over $50 beat 10% off", "try a buy-more-save-more deal", "test a spend-$100-get-$15 threshold offer", "give a free tote over $150". Works on all plans. Each test group carries an offer made of one or more `parts`: `amount-off-products` (scope: all/specific products/collections), `amount-off-order`, `shipping-discount` (scope: all/specific rate names), `volume-discount` (qty tiers, ascending), `threshold-discount` (subtotal tiers, ascending), or `free-gift`. Each discount part has a `value` (`percentage` 0–100 or `fixedAmount` in store currency) and optional `condition` (min-subtotal / min-quantity; a min-subtotal amount is in store currency, converted at Shopify's rate at checkout). A `free-gift` part has no `value`: it adds one product variant (`gift`) to the cart at no charge once its required `condition` is met, counting only what its `scope` covers (default all products; the gift itself never counts), with `autoAdd` default true. Keep the gift product out of any other product discount in the same group. The control group is typically the no-offer arm (empty `parts`); variant groups need ≥1 part. *** Resolve product/collection GIDs with list_shop_products / list_shop_collections before building specific-products/collections scopes or a gift. *** Group percentages must sum to 100. `combinesWith` controls discount stacking (defaults to all true; `shippingDiscounts` is forced false whenever any part is `shipping-discount` because Shopify rejects shipping discounts that also combine with shipping discounts). Defaults to a draft — call `start_experiment` to launch.
create_offer_test
Four inputs shape test quality and are best taken from what the merchant actually asked for rather than left to default: (1) `hypothesis` — what the test is expected to prove (e.g. "10% off lifts revenue per visitor"); (2) `experimentGoal` — the primary metric that defines success (revenue_per_visitor, conversion_rate, average_order_value); (3) `trafficAllocationPercent` — the share of visitors who enter the test (default 100); (4) `audienceTargeting` — an optional filter on who enters the test, relevant only when the request implies one ("test only on mobile", "US visitors only"). A test created with none of these set is valid but weak: no stated hypothesis, no primary metric, full traffic, and no audience filter. Naming: the ABConvert dashboard labels `audienceTargeting` "Audience" (who enters the test) and labels `forceAssignRules` "Targeting" (override the random split for specific visitors). They are separate features, so "audience" or "audience filter" is the accurate term for `audienceTargeting`. Launch behavior: `saveAsDraft` defaults to true and creates a draft that receives no traffic. Passing `saveAsDraft: false` launches immediately and changes what real customers see, so it reflects an explicit instruction to go live ("launch it immediately", "go live now", "skip the draft step") rather than a bare confirmation of the settings. A draft can be launched later with `start_experiment` or checked first with `preview_experiment`. --- Set up a price A/B test on one or more Shopify products. Use when the user says things like "test a 10% discount on the hoodie", "try a $5 markup", "see if a sale price lifts conversion", "split traffic 50/50 between current and discounted price". You build the test groups (one control with priceChange=0, one or more variants). Each group sets a uniform change via its variation rule; for specific per-variant prices ("small $19.99, large $24.99") set variantPrices on the group instead. Pass product GIDs only — this tool resolves variants from Shopify and the shop's primary market itself. Group percentages must sum to 100. Defaults to a draft — call start_experiment afterwards to launch. Resolve product names to GIDs with list_shop_products first if the user gave you a name. To test every product of some Shopify product types ("10% off all snowboards"), pass scope instead of products: each non-control test group's variation is then its price rule, with optional rounding and rulesByType for a different rule per product type.
create_price_experiment_v2
Four inputs shape test quality and are best taken from what the merchant actually asked for rather than left to default: (1) `hypothesis` — what the test is expected to prove (e.g. "10% off lifts revenue per visitor"); (2) `experimentGoal` — the primary metric that defines success (revenue_per_visitor, conversion_rate, average_order_value); (3) `trafficAllocationPercent` — the share of visitors who enter the test (default 100); (4) `audienceTargeting` — an optional filter on who enters the test, relevant only when the request implies one ("test only on mobile", "US visitors only"). A test created with none of these set is valid but weak: no stated hypothesis, no primary metric, full traffic, and no audience filter. Naming: the ABConvert dashboard labels `audienceTargeting` "Audience" (who enters the test) and labels `forceAssignRules` "Targeting" (override the random split for specific visitors). They are separate features, so "audience" or "audience filter" is the accurate term for `audienceTargeting`. Launch behavior: `saveAsDraft` defaults to true and creates a draft that receives no traffic. Passing `saveAsDraft: false` launches immediately and changes what real customers see, so it reflects an explicit instruction to go live ("launch it immediately", "go live now", "skip the draft step") rather than a bare confirmation of the settings. A draft can be launched later with `start_experiment` or checked first with `preview_experiment`. --- Set up a shipping A/B test on one or more of the merchant's Shopify delivery zones. Use when the user says things like "test a $14.99 Express rate against the current $9.99", "try free shipping over $50", "raise my standard rate", "test removing free shipping". Required steps: call `list_shipping_profiles` first, then build test groups (one control with no rate overrides, one or more variants each supplying `ratesPerZone` for every zone in `zoneIds`). Each `ratesPerZone[]` entry has two fields, both optional but at least one must be non-empty: (a) `rates` — rates the variant ADDs or MODIFIEs. To MODIFY a native, set `originalRateId` to the native id (from `list_shipping_profiles[].zones[].nativeRates[].id`); to ADD a brand-new rate, omit it. (b) `hideRateIds` — native rate ids to HIDE from the variant (for "test removing X" prompts). Every native NOT referenced in `rates` AND NOT listed in `hideRateIds` is auto-preserved as a pass-through — don't enumerate the entire rate list. Prices and `condition.minimum`/`maximum` are DECIMAL (14.99 for $14.99, 50 for "free over $50"); the tool converts to smallest currency unit. Group percentages must sum to 100. Defaults to a draft — call `start_experiment` to launch. Simplified-shipping mode only; refuses if the shop is not opted in.
create_shipping_test
Four inputs shape test quality and are best taken from what the merchant actually asked for rather than left to default: (1) `hypothesis` — what the test is expected to prove (e.g. "10% off lifts revenue per visitor"); (2) `experimentGoal` — the primary metric that defines success (revenue_per_visitor, conversion_rate, average_order_value); (3) `trafficAllocationPercent` — the share of visitors who enter the test (default 100); (4) `audienceTargeting` — an optional filter on who enters the test, relevant only when the request implies one ("test only on mobile", "US visitors only"). A test created with none of these set is valid but weak: no stated hypothesis, no primary metric, full traffic, and no audience filter. Naming: the ABConvert dashboard labels `audienceTargeting` "Audience" (who enters the test) and labels `forceAssignRules` "Targeting" (override the random split for specific visitors). They are separate features, so "audience" or "audience filter" is the accurate term for `audienceTargeting`. Launch behavior: `saveAsDraft` defaults to true and creates a draft that receives no traffic. Passing `saveAsDraft: false` launches immediately and changes what real customers see, so it reflects an explicit instruction to go live ("launch it immediately", "go live now", "skip the draft step") rather than a bare confirmation of the settings. A draft can be launched later with `start_experiment` or checked first with `preview_experiment`. --- Create a subscription plan A/B test for Recharge, Stay.AI, or SKIO. First call list_shop_products and list_subscription_plans for every product; use the returned provider plan id for each subscription product. Use testGroups[].offers for multiple products and purchaseType: one-time for a plan-free test group. Every test group must cover the same products. Stay.AI and SKIO also require the returned Shopify selling plan id for subscription rows. Defaults to a draft. Before launch, use get_launch_checks; start_experiment rechecks provider connections, plan ownership, and storefront readiness.
create_subscription_test
Four inputs shape test quality and are best taken from what the merchant actually asked for rather than left to default: (1) `hypothesis` — what the test is expected to prove (e.g. "10% off lifts revenue per visitor"); (2) `experimentGoal` — the primary metric that defines success (revenue_per_visitor, conversion_rate, average_order_value); (3) `trafficAllocationPercent` — the share of visitors who enter the test (default 100); (4) `audienceTargeting` — an optional filter on who enters the test, relevant only when the request implies one ("test only on mobile", "US visitors only"). A test created with none of these set is valid but weak: no stated hypothesis, no primary metric, full traffic, and no audience filter. Naming: the ABConvert dashboard labels `audienceTargeting` "Audience" (who enters the test) and labels `forceAssignRules` "Targeting" (override the random split for specific visitors). They are separate features, so "audience" or "audience filter" is the accurate term for `audienceTargeting`. Launch behavior: `saveAsDraft` defaults to true and creates a draft that receives no traffic. Passing `saveAsDraft: false` launches immediately and changes what real customers see, so it reflects an explicit instruction to go live ("launch it immediately", "go live now", "skip the draft step") rather than a bare confirmation of the settings. A draft can be launched later with `start_experiment` or checked first with `preview_experiment`. --- Set up a Liquid template A/B test on the merchant's storefront. Use when the user says "test the alternate product page", "try a different collection layout", "compare homepages". Required steps: call `list_shop_templates` with the right `type` (product/collection/index/ page/blog/article/cart/search) to discover available templates, then build test groups (one control with the default template `suffix: ""`, one or more variants each pointing at an alternate via `templateKey` + `templateSuffix`). Pass `themeId` from list_shop_templates. Group percentages must sum to 100. For product/collection/page templates pass `previewHandle` (the product the test is about) so the dashboard can preview each group. Defaults to a draft — call `start_experiment` to launch. (Path-condition routing — "test only on /products/handle" — is not exposed via MCP today; merchants can add path filters in the ABConvert dashboard after the test is drafted.)
create_template_test
Four inputs shape test quality and are best taken from what the merchant actually asked for rather than left to default: (1) `hypothesis` — what the test is expected to prove (e.g. "10% off lifts revenue per visitor"); (2) `experimentGoal` — the primary metric that defines success (revenue_per_visitor, conversion_rate, average_order_value); (3) `trafficAllocationPercent` — the share of visitors who enter the test (default 100); (4) `audienceTargeting` — an optional filter on who enters the test, relevant only when the request implies one ("test only on mobile", "US visitors only"). A test created with none of these set is valid but weak: no stated hypothesis, no primary metric, full traffic, and no audience filter. Naming: the ABConvert dashboard labels `audienceTargeting` "Audience" (who enters the test) and labels `forceAssignRules` "Targeting" (override the random split for specific visitors). They are separate features, so "audience" or "audience filter" is the accurate term for `audienceTargeting`. Launch behavior: `saveAsDraft` defaults to true and creates a draft that receives no traffic. Passing `saveAsDraft: false` launches immediately and changes what real customers see, so it reflects an explicit instruction to go live ("launch it immediately", "go live now", "skip the draft step") rather than a bare confirmation of the settings. A draft can be launched later with `start_experiment` or checked first with `preview_experiment`. --- Set up a theme A/B test on the merchant's Shopify storefront. Use when the user says "test our Dawn theme against Refresh", "try the new theme on half my traffic", "see if the redesign converts better". Required steps: call `list_shop_themes` first to get numeric theme ids, then build test groups (one control with the current MAIN theme, one or more variants each pointing at a different theme via `themeId`). Group percentages must sum to 100. Defaults to a draft — call `start_experiment` to launch. (Path-condition routing — "test only on /products/*" — is not exposed via MCP today; merchants can add path filters in the ABConvert dashboard after the test is drafted.)
create_theme_test
Four inputs shape test quality and are best taken from what the merchant actually asked for rather than left to default: (1) `hypothesis` — what the test is expected to prove (e.g. "10% off lifts revenue per visitor"); (2) `experimentGoal` — the primary metric that defines success (revenue_per_visitor, conversion_rate, average_order_value); (3) `trafficAllocationPercent` — the share of visitors who enter the test (default 100); (4) `audienceTargeting` — an optional filter on who enters the test, relevant only when the request implies one ("test only on mobile", "US visitors only"). A test created with none of these set is valid but weak: no stated hypothesis, no primary metric, full traffic, and no audience filter. Naming: the ABConvert dashboard labels `audienceTargeting` "Audience" (who enters the test) and labels `forceAssignRules` "Targeting" (override the random split for specific visitors). They are separate features, so "audience" or "audience filter" is the accurate term for `audienceTargeting`. Launch behavior: `saveAsDraft` defaults to true and creates a draft that receives no traffic. Passing `saveAsDraft: false` launches immediately and changes what real customers see, so it reflects an explicit instruction to go live ("launch it immediately", "go live now", "skip the draft step") rather than a bare confirmation of the settings. A draft can be launched later with `start_experiment` or checked first with `preview_experiment`. --- Set up a URL-redirect A/B test: send variant traffic to a different landing page than control. Use when the user says "test our new landing page", "split traffic between /sale and /flash-sale", "send half the visitors to the new product detail layout". URLs can be resolved from the user's natural-language description instead of asking them to type paths. For pages (`/pages/<handle>`) call `list_shop_pages` with a `q` matching the user's phrase. For products (`/products/<handle>`) call `list_shop_products`. For collections (`/collections/<handle>`) call `list_shop_collections` (returns `/collections/all` automatically). For special paths (`/`, `/cart`, `/search`) just pass them directly. Pick a sensible `experimentName` yourself ("Sale → Flash Sale redirect") instead of asking — the merchant can rename in the dashboard. Each test group has one or more rules pairing `triggerUrl` (with a `matchType` like "match_exactly", "contains", "starts_with") and `destinationUrl`. Control rules can leave `destinationUrl` empty (visitors stay on the trigger page); variants must supply one. Group percentages must sum to 100. Defaults to a draft — call `start_experiment` to launch.
create_url_redirect_test
Create drafts or receive exact build briefs for selected Idea Bank cards.
create_test_from_idea
Save changes to a checkout test that exists: add, change or remove its blocks (built-in and Custom), shipping and payment rules, and post-purchase offers. Pass the changes the merchant approved in preview_checkout_test, exactly as previewed: the save applies them the same way and runs the same checks, so the test ends up as the preview showed it once any `setup` steps are complete. Use get_checkout_test for the ids of what is there. Answers the changed `blocks` (placement, test groups, summary, cartConditionsByTestGroup), `rules` and `offers`; `removed` names what the edit took out; and, when the merchant has something to do in Shopify's checkout editor, `checkoutEditor`. Pass through `warnings`, including ORDER_DISCOUNT_UNVERIFIED, and its suggested check before launch. PREVIEW FIRST: before saving a checkout change, preview it with preview_checkout_test (`proposal` for a new test, `experimentId` and `changes` for one that exists) and show the merchant. Each preview carries every change not saved yet, not only the latest: when the merchant asks for another change, preview the whole revised list again. Save only once they approve, exactly the last list you previewed: create_checkout_test with the same proposal for a new test, edit_checkout_test with the same changes for one that exists. When the chat shows no preview, describe it in plain words from the answer's `blocks` and `rules`. If part of the request cannot be built, say exactly what is unsupported before building. Do not write copy promising it. After building, explicitly list any requested outcome that was not fulfilled, even when the rest was saved. PLACING BLOCKS: a checkout block shows at checkout only once the merchant adds its app block in Shopify's checkout editor. What to add is the answer's `checkoutEditor`, with `checkoutEditorUrl` and `blocks`, each with `block` (the app block to add), `placement` (where, such as "Before contact"), `summary` (what it shows, and in which test groups), for an ABConvert Checkout Block, `blockId`, and for a block on the Thank you or Order status page, its own `checkoutEditorUrl` and `pageStep` and `after`, the Block ID of the ABConvert block it goes under (the entry listed just before it at that placement, or one already there). It lists only the app blocks this edit added; an empty `blocks` adds none, and needs no Preview. When an entry has `after`, its bold line reads "**<placement>**, under the ABConvert block with Block ID <after>: <summary>". Put the test in Preview before you give the steps: the checkout editor shows a block's content only for a test in Preview or running, and for a Draft it shows a warning that no test targets the Block ID. So when the test is a Draft and every Custom block in it is built, call preview_experiment with its ID, without asking: real shoppers are not assigned to a test in Preview. If it refuses, tell the merchant what to fix, from each finding's `fix` and `fixUrl` when it has them, and give the steps once it passes. Give the steps as one numbered list, whatever the number of blocks, with the entries in the answer's order (blocks that share a placement are added in that order; a Block ID several test groups share is added once): 1. Open the checkout editor: [Open checkout editor](<checkoutEditorUrl>) 2. Add an ABConvert Checkout Block at each placement below, and in each block's settings set Block ID to the one shown: **<placement>**: <summary> ``` <blockId> ``` 3. Save the checkout editor. Repeat the bold line and its code block under step 2 for each entry with a blockId, indented so the numbering holds. Put the Block ID alone in its code block, with nothing else on the line, so the merchant can copy it. An entry with no blockId (ABConvert Cart Control) gets its own step before the save: "Add the ABConvert Cart Control at <placement>. No Block ID needed." An entry with `pageStep` goes on the Thank you or the Order status page (its `pageStep` names which), which the answer lists after the Checkout page, Thank you first: give each page's entries their own steps after the save, "Open the <page> page: [Open checkout editor](<its checkoutEditorUrl>)", then "In the page menu at the top of the editor, choose <page>", then, for each, its `pageStep` (where in the editor to add the ABConvert Checkout Block) with the bold line and Block ID code block as in step 2, then save again. When every entry is on one such page, those are the whole list: step 1 opens that page and step 2 says to choose it in the page menu at the top of the editor. When no entry has a blockId, leave out step 2. When preview_experiment gave a `previewUrl`, give it after the list, for checking the test on the store once the editor is saved. Always show Block IDs: unlike other ids, the merchant types them into the checkout editor. When `checkoutEditor` has `unusedBlockIds`, no block holds those Block IDs any more (a removal moves the blocks after it up), so the ABConvert block with each of them now shows nothing: tell the merchant to delete it in the checkout editor, so a later block given the same Block ID is not added twice. `unusedBlockIds` are on the Checkout page. Those on the Thank you page come in `unusedOnThankYou` instead, and those on the Order status page in `unusedOnOrderStatus`, each with its own `checkoutEditorUrl` and `pageStep`: give each as a separate step that opens that link, gives the `pageStep`, and names each Block ID to delete there. One Block ID can be on several pages, so always say which page the block to delete is on. LIMITS: only Draft and Preview tests change, scheduled ones included; a Preview test's preview link shows the change at once. Never revert, pause or end a test to change it: a running or paused test is changed in the ABConvert admin. If the merchant has the test open in the ABConvert admin with unsaved changes, ask them to save first: their next save would replace yours. A refusal saves nothing and says what to fix. After an error with no answer, read the test with get_checkout_test before sending again: an addBlock sent twice adds two blocks. STORE SETUP: an answer has `setup` only when the test uses a store setting that is not ready: the post-purchase page app (for a post-purchase offer) or the ABConvert checkout check (for a paid add-on with required text or a Custom block with Pay checks). Then show `setup.guide` to the merchant as it is, with no steps added or reworded, and when `setup.checkoutCheck.canTurnOn` is true, offer to turn the check on for them with turn_on_checkout_check. With no `setup`, say nothing about setup.
edit_checkout_test
Use this to change an element on the page in the editor tab, or the test group’s custom CSS or JavaScript; `changes` makes several in one call. It edits the draft or preview, which shoppers see only once the test launches. A live personalization (`test.live`) is live at once, so ask first. - `set` sets only the properties you name; the rest of the change stays. - To reorder, use `node.position` { after } or { before }, never CSS `order`. - `action: revert` drops the element’s whole change, whenever it was made. The answer has the event (what changed) and: - `matched`: how many changes found their element. 0: none on this page. null: no tab reported, or it shows another test group. - `elements`: more than the changes means the page repeats it (a carousel’s copies). - `overflow`: wider than its space. Fix that first. - `render`: box, font size, lines, clipped, offscreen, on `desktop` and `mobile`. Check it, not a browser. Not for adding elements (editor_insert_elements) or undo (editor_edit_history).
editor_edit
Permanently conclude an experiment and lock in the result. Use when the user says "end the test", "call it", "wrap it up", "stop and finalize", "we have a winner". Cannot be resumed afterwards. For a temporary halt use pause_experiment. This is also how you remove a test from MCP: deleting experiments is disabled for MCP, so if the user asks to "delete" or "remove" a test, end it instead (ending preserves the results), or point them to the ABConvert admin for a hard delete.
end_experiment
Use this to get the `target` of the element the merchant means, on the page in the editor tab, before editor_edit or editor_insert_elements. Search by its words, role (heading, link, button, img, listitem, ...), tag or a CSS selector. The tab searches its whole page, hidden elements included. Returns candidates, best first, each with its `target`, where it sits and whether a shopper sees it now. Some carry a flag: - `repeat`: one of several alike siblings. An edit changes only this one. To add to the list, pass it to editor_insert_elements as `after`. `role: listitem` finds such items whatever their tag. - `copies`: the same words, link or image at another address, such as a menu’s phone copy, an image’s thumbnail, or a photo’s phone slide. To change or move it everywhere, edit each one. - `clone`: a carousel’s copy of a slide, sharing the slide’s address. - `shadow` or `frame`: a widget. Nothing inside it can be edited. An `overlay` in the answer means a popup covers the merchant’s tab.
editor_find_elements
Run the full autopilot orchestrator on the merchant's shop and return the ranked recommendation inbox. Fans out OrderAnalyzer + all three funnel-track recommenders (Shipping/Price/Offer) + Ranker. Returns the same payload as the embedded-app /autopilot page. Use this to verify recommender output, inspect createInput shapes, or debug ranking without refreshing the admin UI. Read-only.
get_autopilot_recommendations
Check again whether the store settings a checkout test uses are ready, after the merchant says they did a step from a setup guide, or before launching. The create, preview, edit and read answers of a checkout test already carry `setup` when something is needed, so you rarely need this first. Pass `experimentId` for a test that exists; for one not created yet, `for` with only the settings it uses. Answers `ready: true` when nothing is left to do, and say nothing about setup then; else `setup` with each setting not ready and `guide`, the steps as markdown, to show as it is. STORE SETUP: an answer has `setup` only when the test uses a store setting that is not ready: the post-purchase page app (for a post-purchase offer) or the ABConvert checkout check (for a paid add-on with required text or a Custom block with Pay checks). Then show `setup.guide` to the merchant as it is, with no steps added or reworded, and when `setup.checkoutCheck.canTurnOn` is true, offer to turn the check on for them with turn_on_checkout_check. With no `setup`, say nothing about setup.
get_checkout_setup
Read a checkout test's blocks and shipping and payment rules, before previewing changes to it or when the merchant asks what a test group shows at checkout. Answers each test group's name and its modifications (as JSON text), and `blocks` and `rules`: per block its modId, Block ID, type, placement ("Before contact"), test groups, a summary of what it shows and, when it shows only for some carts, `cartConditionsByTestGroup`: per test group its `cartConditions`, one line per condition set, and it shows when any holds (a test group with none shows it for every cart); per rule its modId, test group and a summary such as "Hide Express when the cart is over $200"; and `offers`: per post-purchase offer its modId, test group, product variant, pricing, heading, description and, when it shows only for some orders, its showWhen. Pass block, rule and offer ids in the changes of preview_checkout_test and edit_checkout_test. STORE SETUP: an answer has `setup` only when the test uses a store setting that is not ready: the post-purchase page app (for a post-purchase offer) or the ABConvert checkout check (for a paid add-on with required text or a Custom block with Pay checks). Then show `setup.guide` to the merchant as it is, with no steps added or reworded, and when `setup.checkoutCheck.canTurnOn` is true, offer to turn the check on for them with turn_on_checkout_check. With no `setup`, say nothing about setup.
get_checkout_test
(Beta) Read the Custom checkout blocks of a checkout test, before changing one or when the merchant asks what a block shows. Answers the test's test group names and, for each Block ID: its placement ("Before contact"), the test groups holding it, and whether it is built. A built block also has its name, its visibility rule in words, `shows` (its text for three sample carts), `cartConditionsByTestGroup` when the whole block shows only for some carts (per test group, one line per condition set; a test group with no `cartConditions` shows it for every cart), and `tree`: its current tree as JSON text, to edit, preview with preview_checkout_test and send back whole to save_custom_checkout_block. A block that is not built has no tree yet: build it from scratch. `editable` says whether the test can still change (Draft and Preview tests only, scheduled ones included); when it is false, `notEditable` says why and what the merchant does instead.
get_custom_checkout_blocks
Read the full configuration of one specific experiment — test groups, products or subscription plans under test, traffic split, status, audience targeting. Use this after `list_experiments` to drill into one the user picked, or when the user references a known experiment by id. For performance numbers (revenue, conversion), use `get_experiment_results` instead. When available, `experiment.productGroups` lists the product groups (a collection or set of products) as `{id, name}`. When the user names products, such as "the Snowboards products" or "the Test Products collection", match that name to a product group here and pass its `id` as `groupId` to `get_experiment_results` or `get_experiment_breakdown`. If no product group matches, say so and do not return unscoped results as if they were scoped.
get_experiment
Slice experiment results by one or two dimensions to see where lift is coming from. Supported snake_case dimensions: date, country, market, device, visitor_type, traffic_channel, traffic_platform, referral_domain, landing_page, utm_source, utm_medium, utm_campaign, utm_term, utm_content, page_url, template, click_destination, product_id. Use startDate/endDate for an inclusive shop-local window, sampleBasis for assignment/exposure, metricSet=engagement for engagement metrics, and groupId for a product-group scope. product_id is available only with groupId. The backend supports custom-event population filters here: customEventRuleId and customEventSegment=include|exclude must be supplied together. Computes and caches results on demand: the tool reads first and only requests metered computation when that exact identity has no snapshot; if status="creating", retry in ~30 seconds.
get_experiment_breakdown
Read an experiment's lifecycle timeline — when it was created, updated, paused, resumed, and ended, who did each, and what changed. Use when the user asks "why is this paused?", "when did we launch this?", "what changed on this test?", "show me the history". Returns a compact newest-first timeline of {date, event, user, message, changes}. Pass verbose: true for the raw records including full config snapshots.
get_experiment_history
Get the headline numbers and canonical ABConvert verdict for a test — named test groups, visitors, conversion rate, revenue, AOV, total revenue, profit per visitor, cart and checkout rates, discount metrics, engagement counts and staying time, lift, winner, SRM status, metric units, and warnings. Use this when the user asks "how is my test doing", "is it winning", "what's the lift", or "show me results for [test]". The verdict uses the same goal metric, frequentist significance rule, and sample floors as the dashboard. Scope with inclusive shop-local startDate/endDate, sampleBasis, metricSet, or groupId. customEventMetricId changes only the displayed metric and never the verdict; customEventRuleId plus customEventSegment filters the population. Segmented responses omit the winner and carry a post-treatment warning. The summary also lists registered custom events by ruleId and name. Pass verbose=true only when every raw metric and statistical field is needed. Results are materialized on demand; the backend computes and caches results on demand, so if status="refreshing", retry in ~30s. For device or country slices, use get_experiment_breakdown.
get_experiment_results
Check whether an experiment can launch, without launching it. Returns `canLaunch`, the `blocks` the server would refuse on (for example another running test already claims the same product, template, or page: code RESOURCE_CLAIMED; or a theme test is running: THEME_TEST_RUNNING), and the `warnings` a launch goes through with but the merchant should know about (for example this test will override a running personalization on the same page, or a page overlap with another test that could not be proven). Use when the user asks "can I launch this?", "is anything blocking the launch?", "will this conflict with my other tests?", or before start_experiment on a Draft. start_experiment and preview_experiment run the same checks and include the warnings in their result. Each finding is {code, severity, scope, params}; params name the other experiment and the shared resource. When a finding's params have `fix`, it is something to change in the store, such as a paid add-on's weight or inventory tracking, a product's sales channel or the store's post-purchase app: tell the merchant in plain words what to change, give `fixUrl` as a link to the Shopify admin page where they change it, and offer to check again with get_launch_checks once they have. For POST_PURCHASE_APP_NOT_SELECTED, CHECKOUT_CHECK_OFF and CHECKOUT_CHECK_NEEDS_ACCESS, call get_checkout_setup with the test's experimentId and show its `guide` instead.
get_launch_checks
For a single-store connection, return its `shop_domain` and `storefront_url`. For an agency connection, indicate that stores must be selected with `list_accessible_stores`. Call this only when asked which store is connected or for its storefront URL.
get_shop
Use this to add elements to a list on the page in the editor tab: gallery slides, product cards, menu links. `after` is an item of that list (the li); the `items` follow it, in order. - Prefer `{ src, alt }`: a copy of `after` showing another image (editor_upload_image gives the src). It keeps the theme’s classes, CSS and sliders, and copies the elements tied to it (a slide’s thumbnail) as `copied_with`. - `{ html }` is new markup, wrapped in an li in a list. It must fit every width: no fixed widths, and class names with the layout in the group’s custom CSS. Check it at `device: mobile` too. A product gallery shows the theme’s own media list, so an added slide may get no thumbnail or stay out of reach: prefer swapping a slide’s image with editor_edit. A looping carousel (`clone` slides) refuses an insert. To add after your inserts, pass the last as `after`. Returns each item’s `target` and `matched` (and `render` for one item). Inserts on a live personalization are live at once, so ask first.
editor_insert_elements
List the client stores this named agency connection can currently read. Use this before targeting a store in list_experiments, get_experiment, or get_experiment_results. A merchant can revoke access at any time; the returned list is current, not a permanent grant.
list_accessible_stores
List running tests whose canonical ABConvert verdict identifies a winner and whose runtime is long enough to trust. Use when the user asks "which tests are ready to ship?", "anything I should act on?", or "what won?". The server applies the same goal-metric, frequentist significance, sample-floor, freshness, and SRM rules as the dashboard. The runtime gate defaults to 14 days and is tunable with minDaysRunning. minProbBeatControl is deprecated and ignored.
list_active_winners_to_act_on
Use this to see the test’s saved Visual Editor changes as they are now: per test group, one change per element and page scope, with what it does, where it applies, who made it (user or agent) and its seq. Each group also has `undo` and `redo` (the edit each would act on) and its named `versions`, which editor_edit_history takes. Values over 200 characters are cut unless `detail` is full; the group’s custom CSS is never cut. `key` reads one change.
editor_list_changes
List the merchant's ABConvert experiments. Use this when the user asks about their tests in general terms — "what tests am I running", "show me my experiments", "any drafts left over", "what finished last week". Filter with `status` (Active, Paused, Draft, Closed) and/or `experimentType` to narrow down. Returns a compact row per experiment by default (id, name, type, status, dates); pass verbose=true for full docs. To inspect one experiment's full config, use `get_experiment`.
list_experiments
Use this to read the rounds of comments the merchant sent you from the editor that are still open, oldest first. A round is everything they sent with one Send: `message` (what they want overall), `group_index` (the test group they were looking at) and `comments`, one per element, each with its `pin`, `text`, the element’s `target` (pass it to editor_edit), `role`, `visibleText`, computed `style` (left out with `detail: compact`), `pageUrl`, `device: mobile` when written on the phone view, and `levels` (the level with `move: true` reorders it). Rounds stay open until editor_resolve_comments closes them, so this shows what was sent before you connected. Other editor tools hand you a new round once, under `merchant_comments`; use this to read the open ones again. A round with `held_by_another_ai: true` is another AI’s: leave it unless the merchant says to take over. Use when the merchant says "check my comments", before you report that you are done, or during a long step, so the editor sees you are still here.
editor_list_comments
List the merchant's Shopify delivery profiles, zones, and flat-rate methods so you can compose a shipping-test payload. Use this before `create_shipping_test` whenever the merchant says something like "raise my US Express rate" — you need the zone id and the rates Shopify currently serves there. Returns `{profiles: [{id, name, isDefault, zones: [{id, name, countries, nativeRates: [{id, name, price, currency, condition?, transitTimeMin?, transitTimeMax?}]}]}], simplifiedShipping}`. If `simplifiedShipping` is false, `create_shipping_test` will refuse — the merchant's shop hasn't been opted into PRO-1280 mode and the legacy diff-against-native path is not exposed via MCP.
list_shipping_profiles
Search the merchant's collections and return their handles + storefront paths. Returns `{collections: [{id, title, handle, path, isVirtual}]}` where `path` is the storefront URL like `/collections/snowboards`. Use this whenever the merchant names a collection in plain language ("test traffic from /collections/all to the snowboards collection"). The special `/collections/all` entry is included automatically (Shopify exposes it on every storefront even when no Custom/Smart Collection has that handle) — you can use it without verifying. For pages, use `list_shop_pages`. For products, use `list_shop_products`.
list_shop_collections
Search the merchant's published Online Store pages and return their handles + storefront paths. Returns `{pages: [{id, title, handle, path, templateSuffix}]}` where `path` is the storefront URL like `/pages/sale`. Use this whenever the merchant names a page in plain language ("test traffic from my sale page", "redirect off the contact page") so you can plug `path` into `create_url_redirect_test` without asking. For product or collection URLs, use `list_shop_products` (URLs are `/products/<handle>`); for special URLs like `/`, `/cart`, or `/search`, just use them directly — those don't need a lookup.
list_shop_pages
Search the merchant's Shopify catalog and return product GIDs you can plug into create_price_experiment_v2. Use this whenever the user names a product in plain language ("test the cotton hoodie") instead of asking them for an id. Returns id, title, handle, status, and variant prices.
list_shop_products
List the merchant's Liquid template alternates of a given type for the shop's active theme. Returns `{templates: [{key, suffix, type, isDefault}], themeId}`. Use this before `create_template_test` whenever the merchant wants to test a template alternate (e.g. "test product.alternate against the default product page", "try a different homepage layout"). The default template has `suffix: ""` and `isDefault: true` — typically the control. Supported types: index, collection, product, page, blog, article, cart, search.
list_shop_templates
List the merchant's Shopify themes (active + unpublished) so you can plug their numeric ids into `create_theme_test`. Returns `{themes: [{id, name, role}]}` where `role` is the Shopify enum (MAIN, UNPUBLISHED, MOBILE, DEMO, DEVELOPMENT). The MAIN theme is the live one — pick it as the control. Use this whenever the merchant says something like "test our Dawn theme against the new Refresh draft", "try a different theme", "see if the new theme converts better".
list_shop_themes
List the connected Recharge, Stay.AI, or SKIO subscription plans for one Shopify product. First use list_shop_products to find the product GID, then call this tool with its provider. Use returned id in create_subscription_test, plus shopifySellingPlanId for Stay.AI or SKIO. Recharge has no Shopify selling plan ID in this response. Never guess plan IDs.
list_subscription_plans
List ranked test ideas, or pass idea_id to return one visible idea with its drawer details.
list_test_ideas
Move the merchant’s editor tab to another page of their store, and wait until it has loaded. Returns the `page_url` the tab landed on. Your next editor_get_page_context, editor_find_elements and editor_edit act on that page. Use list_shop_products, list_shop_collections or list_shop_pages to find a page’s path.
editor_navigate
Open a Visual Editor session on a test. Shoppers see edits to a draft or preview once it launches, and to a live personalization (`test.live`) at once: ask first. Returns `session_id` (for every other editor tool), `editor_url`, the test’s groups (`index` is editor_edit’s group_index) and a `cursor`. Other editor tools need a tab open on the test. If the merchant has none, open `editor_url`: - If you have a browser they can see, open it there and say so. - Either way, give it as one plain markdown link (for any browser) that "opens your store in a new tab", never in a code block or repeated. To check their comments, call editor_list_comments; their tab is open. Once they have the link, call editor_wait_for_events with the returned `cursor`, in the background if you can. Without `experiment_id` it creates a Visual Editor draft (Control and Variant A, 50/50), whose `experiment_id` goes to preview_experiment and start_experiment. Launching needs the merchant’s yes.
editor_open
Temporarily stop an active experiment without ending it — preserves data and can be resumed later. Use when the user says "pause", "hold", "stop for now", "take a break". For permanent stop use end_experiment.
pause_experiment
Diagnostic only — confirms the MCP server can reach ABConvert and the API token is valid. Don't call this proactively; only use it when the user explicitly asks to check the connection or when another tool just failed and you need to isolate whether it's a connectivity problem.
ping
Preview a checkout test before it is saved: a new one (`proposal`, the input you would pass to create_checkout_test) or changes to one that exists (`experimentId` and `changes`). Saves nothing. Runs the save checks except post-purchase app selection, which appears in `setup` so the offer can be drawn before it is ready. In a chat that shows app views, the merchant sees each page the change is on as that test group's shoppers will, on desktop and mobile, with the changed blocks outlined, and can switch test groups, sample carts and pages (Checkout, Post-purchase, Thank you, Order status). Answers `blocks` (each changed block's placement, test groups, what it shows and its `cartConditionsByTestGroup`), `rules` (each changed rule in words), `offers` (each post-purchase offer in the proposal or changes: test group, product facts, heading, description, pricing and showWhen) and `next`. The preview draws a block for every sample cart, its cart conditions or not: tell the merchant which carts it shows for, from `cartConditionsByTestGroup`. When the merchant cannot see the preview, describe those in plain words. An addBlock's props per blockType are those create_checkout_test's block `props` describes. A post-purchase offer can be previewed before its store setup is ready; follow `setup` before saving. If `warnings` names ORDER_DISCOUNT_UNVERIFIED, explain that this checkout test does not create the promised order discount. Check for a matching store discount and tell the merchant if that reward was not built. PREVIEW FIRST: before saving a checkout change, preview it with preview_checkout_test (`proposal` for a new test, `experimentId` and `changes` for one that exists) and show the merchant. Each preview carries every change not saved yet, not only the latest: when the merchant asks for another change, preview the whole revised list again. Save only once they approve, exactly the last list you previewed: create_checkout_test with the same proposal for a new test, edit_checkout_test with the same changes for one that exists. When the chat shows no preview, describe it in plain words from the answer's `blocks` and `rules`. If part of the request cannot be built, say exactly what is unsupported before building. Do not write copy promising it. After building, explicitly list any requested outcome that was not fulfilled, even when the rest was saved. BUILT-IN BLOCKS FIRST: when the merchant has not chosen a block type, check whether a built-in block type does what they asked, and use it when one does: the merchant can change it in the ABConvert admin form without an AI. Built-in types: heading (a title); banner (a message with a tone); trust-badge (reassurance rows such as secure checkout or free returns); benefit (selling points with icons); faq (questions shoppers tap to see the answer, such as shipping and returns); payment-icon (accepted payment brand icons); image (images, one or a carousel); button (link, email or call buttons); upsell-product-tile (products to add to the order); paid-add-on (paid services such as gift wrap, as checkboxes); custom-fields (shown to the merchant as Gift message: one question for the shopper, such as a gift checkbox and message, saved on the order); reviews (real reviews from the store's review app); rewards-progress (progress toward free shipping, a free gift or a discount); cart-control (lets shoppers change quantities and product variants, remove items, or switch an item to a subscription plan, under the cart lines); next-order-discount (shown to the merchant as Next-order discount: after payment, a discount code for the buyer's next order to copy, with up to 3 products to come back for; ABConvert creates the Shopify discount). On the Thank you and Order status pages (the thank-you-* and order-status-* placements) only heading, banner, button, benefit, image and next-order-discount blocks show, and next-order-discount shows only there. Here, a built-in block is an addBlock with that blockType (or a `kind: "block"` modification in a proposal). An explicit request for a Custom block takes precedence over the built-in suggestion. Build a Custom block when none fits, such as content that changes with each cart line, a message for subscription carts, or a layout no built-in type has, and tell the merchant which built-in type came closest and why it did not fit. STORE SETUP: an answer has `setup` only when the test uses a store setting that is not ready: the post-purchase page app (for a post-purchase offer) or the ABConvert checkout check (for a paid add-on with required text or a Custom block with Pay checks). Then show `setup.guide` to the merchant as it is, with no steps added or reworded, and when `setup.checkoutCheck.canTurnOn` is true, offer to turn the check on for them with turn_on_checkout_check. With no `setup`, say nothing about setup.
preview_checkout_test
Use this to put a draft test into Preview and get a storefront link the merchant opens to check the test on their live store before launch; real shoppers are not assigned to it. Use when they say "preview the test" or "let me see it before launching". Answers `previewUrl`: give the merchant the whole URL, never shortened (its `abconvert_preview_key` and `abconvert_experiment_id` are what make it work), as a link and as plain text they can copy to share. Anyone with the link sees the preview. To launch afterwards, use start_experiment; preview takes the same test types. Its `warnings`, and a refusal's `blocks`, are launch check findings as get_launch_checks describes them. `launchChecksReason` explains an unavailable advisory preflight. When a finding's params have `fix`, it is something to change in the store, such as a paid add-on's weight or inventory tracking, a product's sales channel or the store's post-purchase app: tell the merchant in plain words what to change, give `fixUrl` as a link to the Shopify admin page where they change it, and offer to check again with get_launch_checks once they have. For POST_PURCHASE_APP_NOT_SELECTED, CHECKOUT_CHECK_OFF and CHECKOUT_CHECK_NEEDS_ACCESS, call get_checkout_setup with the test's experimentId and show its `guide` instead.
preview_experiment
Use this to see what the page open in the merchant’s editor tab is made of: its URL and template, the theme’s sections in order, the store’s fonts and colors, and `outline`, one line per element (tag, text, links, images), indented by depth. The outline marks elements (changed by this test), (inserted by this test), (moved by this test) and (hidden). It also marks shadow DOM widgets and iframes, which cannot be edited. A long page is cut. A cut branch ends in "read with selector ...": pass that selector to read it. A read with a selector returns only the outline. Not for an element’s address: editor_find_elements gives the `target` that editor_edit takes.
editor_get_page_context
Mark one round of the merchant’s comments handled, with a short `summary` of what you did and `not_done` for any comment you could not do. The merchant sees the round as done, with your summary, in the editor, and the round stops being handed to you. Call it once the whole round is dealt with: the changes are applied, or the merchant decided against them. A round already handled stays as it was. The answer hands you the rounds still waiting, if any; otherwise call editor_wait_for_events again: the merchant sends their next round without telling you. A round another AI is working on cannot be resolved here.
editor_resolve_comments
Continue a previously paused experiment. Use when the user says "resume", "unpause", "pick it back up", "start running it again". Only valid on paused tests.
resume_experiment
Pull a previewed experiment back to Draft so its setup can be edited before launching. Use when the user says "put it back to draft", "un-preview it", "I need to change something before launching", "cancel the preview". Only valid on a Preview experiment (one that went through preview_experiment). To launch a preview instead of reverting it, use start_experiment.
revert_experiment_to_draft
ABConvert ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve ABConvert's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are ABConvert alternatives on ChatGPT?
As of 2026-11-20, ABConvert competes with Run With AI, Shopify, 1stPage, 3DMockups, AfterShip Post-Purchase, AIOD Discounts & Free Gift, auction.fish, AutoFire and 92 more in ChatGPT Ecommerce Operations Platforms, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.