epinium_apply_task
ChatGPTWrites the approved suggestions of ONE task to the real entities. Campaign changes (daily budget, state, name) go to Amazon straight away, so applied and failed are real verdicts. Product changes are QUEUED in a batch: enqueued counts them and bulk is the batch id, NOT a confirmation - read the suggestions again later and look at appliedAt and applyError. Approved suggestions that nothing knows how to apply are counted in skipped and nothing happens to them. Pass itemIds to apply only some of them. This changes live campaigns and listings, so ask the user first. Pass idempotency_key and reuse it on retries: two calls with different keys apply twice.
epinium_archive_adgroup
ChatGPTArchives ONE ad group. This cannot be undone. Ask the user before calling it, and check they do not just want to pause it - pausing is reversible, archiving is not. Pass idempotency_key.
epinium_archive_campaign
ChatGPTArchives ONE campaign. This cannot be undone: an archived campaign does not come back, and it is the only irreversible operation in this API. Ask the user before calling it, and make sure they mean archive and not pause - if they only want to stop the spend, set state: "PAUSED" with the update tool, which is reversible. Pass idempotency_key.
epinium_archive_product_ad
ChatGPTArchives ONE product ad: the product stops being advertised in that ad group. This cannot be undone. To stop it temporarily, set state: "PAUSED" instead. Pass idempotency_key.
epinium_archive_target
ChatGPTArchives ONE target: the keyword or product stops existing in the ad group. This cannot be undone - a target cannot be un-archived, it has to be created again. To stop it temporarily, set state: "PAUSED" instead. Pass idempotency_key.
epinium_clone_workflow
ChatGPTCopies an existing workflow of the account — its graph, its declared variables and its schedule — without you resending any of it. This is how you duplicate one: reading a workflow and re-posting its 75 nodes and 80 edges through epinium_create_workflow costs tens of thousands of tokens and gets you the same result. variables takes ONLY the keys whose value you want to change, as a flat {key: value} map; every other variable keeps the source value, and a key the source does not declare is a 400 rather than a silently ignored override. Like every write here the copy is PAUSED, and it starts with NO campaigns attached — membership is stored per campaign, not on the workflow, so epinium_list_workflow_campaigns on the copy reports manual-sin-enlaces until somebody links campaigns to it in Epinium.
epinium_create_adgroup
ChatGPTCreates one ad group inside an existing Sponsored Products campaign. Created PAUSED unless you pass state="ENABLED". defaultBid is clamped to the marketplace limits rather than rejected, so the bid you get back may differ from the one you sent. The campaign must already be published on Amazon. Pass idempotency_key and reuse it on retries.
epinium_create_campaign
ChatGPTCreates one Sponsored Products campaign. It is created PAUSED unless you pass state="ENABLED": an enabled campaign starts spending as soon as Amazon accepts it, so ask the user before enabling one. dailyBudget is checked against the marketplace minimum and rejected below it. Pass idempotency_key and REUSE THE SAME VALUE if you retry the same intent - without that, a network timeout becomes two campaigns. Archiving and deleting are not available through this API.
epinium_create_cluster
ChatGPTCreates one keyword cluster in the account: a named group of catalog products with the positive keywords they should rank or advertise for and the negative keywords to keep away from. Nothing is sent to Amazon; the cluster lives in Epinium and feeds its SEO prompts, the keyword discovery of the optimizer and the cluster filter of the product charts. Only name is required: a cluster can be born empty and filled later with epinium_update_cluster. Each keyword needs keywordText and a language like es-ES or en-GB; epiniumScore (1 to 5) and purpose (SEO, PPC or both; both by default) are optional. Keywords are lowercased and deduplicated; up to 100 positive and 50 negative. products are catalog product ids from epinium_list_products with type seller or vendor - advertising products (type adv) are refused, like any id that does not belong to the account, and the whole call fails naming the offending ids. The cluster is created unprotected and owned by the person behind this credential. Pass idempotency_key and REUSE THE SAME VALUE on retries: without it a timeout creates two identical clusters.
epinium_create_full_campaign
ChatGPTCreates a whole campaign structure in one call: campaign, then ad group, then targets, then product ads. There is NO rollback on Amazon - if a later step fails, what was already created STAYS created, and the response says how far it got in stopped_at with the reasons in partial_errors. Read that instead of retrying: retrying creates a second campaign. Everything is created paused unless asked otherwise. Pass idempotency_key and reuse it on retries.
epinium_create_portfolio
ChatGPTCreates one portfolio in the Amazon Ads account of connection, optionally with a budget cap for all the campaigns you later put in it. MONTHLY_RECURRING and DATE_RANGE need amount, DATE_RANGE also startDate and endDate (YYYY-MM-DD), and NO_CAP takes no amount. The currency is the marketplace one; you do not send it. A cap limits real spend on Amazon, so confirm the amount with the user first. If Amazon rejects it you get result: "failed" with the reason and id: null - do not read the response as success without looking at result. Pass idempotency_key and REUSE THE SAME VALUE on retries: without it a timeout creates two portfolios. Archiving portfolios is not available through this API. To put campaigns in it (Sponsored Products, Brands or Display), use epinium_update_campaigns_batch with its portfolioId.
epinium_create_product_ads
ChatGPTLinks catalog products to an ad group so they get advertised. Products are resolved against the account catalog: one that is missing, or that lacks the identifier the account needs (ASIN for Vendor, SKU for Seller), is reported in failure_details instead of failing the whole call. Created PAUSED unless asked otherwise. Returns COUNTS, not ids. Pass idempotency_key and reuse it on retries.
epinium_create_prompt
ChatGPTCreates one custom prompt in the account: a name (3 characters or more) and an instruction of up to 2,000 characters that the AI must follow when it writes listing content, such as tone, structure or words to use or avoid. fields limits it to titleAndHighlights (title plus Item Highlights, written together), product_description, bullet_point or generic_keyword (search terms); omit it to use the prompt for every field. Nothing is generated and nothing is sent to Amazon: to have it used, link it to keyword clusters with epinium_update_cluster (addPrompts), and content generated afterwards for the products of those clusters follows it. When several prompts of a product's clusters apply to the same field only one of them is used, so keep one prompt per field. The plan of the account caps how many prompts it can have, and a 403 says so. The prompt is owned by the person behind this credential. Pass idempotency_key and REUSE THE SAME VALUE on retries: without it a timeout creates two identical prompts.
epinium_create_targets
ChatGPTCreates targets or negative targets in one ad group, up to 1000 per call. Which types are allowed depends on the ad group: Sponsored Products takes keyword, product and category targets; Sponsored Brands adds THEME; Sponsored Display also takes PRODUCT_AUDIENCE, AUDIENCE, CONTENT_CATEGORY and LOCATION, which need the Amazon id of the audience, category or location. NOT all-or-nothing: the response counts what went in and lists every rejection with its reason, so read failure_details instead of retrying the whole batch. For Sponsored Products, Amazon rules are enforced before sending: negative keywords have length and word-count limits that positives do not; for Brands and Display, Amazon itself returns the reason. It returns COUNTS, not ids: list the ad group targets afterwards if you need them. Pass idempotency_key and reuse it on retries.
epinium_create_task
ChatGPTCreates one Epinium task for the account: what the user will find in their task list, with a title, an optional description, a priority and an optional expiry date. Include up to 50 suggestions in items, each pointing at one entity of this account - that is what makes the task actionable instead of a note. A suggestion that carries fieldPath and the new value in suggestedValue can later be applied to the real entity; for campaigns, fieldPath must be dailyBudget, state or name, and the value must be the value itself (a number, or ENABLED/PAUSED), not a description of the change - anything else is refused. A suggestion without fieldPath is recorded for the user to read and applies to nothing. Suggestions cannot be added after the task is created, so send them all here. Pass idempotency_key and reuse the same value if you retry, or a network timeout becomes two tasks in their list.
epinium_create_workflow
ChatGPTCreates an automation workflow for the account, always PAUSED: it does nothing until a person turns it on in Epinium, and this tool cannot turn it on. That is deliberate — an active workflow moves real bids and budgets on Amazon every night, and a platform-request node that writes changes the connected store. The graph must pass validation, and on failure nothing is written and you get the same error list epinium_validate_workflow returns — so validating first is optional, not a required step, and a rejected create costs you the same round-trip. To copy an existing workflow use epinium_clone_workflow instead: it needs no graph at all. Call epinium_get_workflow on an existing one first to see the shape of a graph that works: its nodes and variables come back in exactly the shape this tool accepts, so they can be resent as-is and edited from there. Layout is not your problem: Epinium places every node and sizes every forEach when it saves, and ignores any position you send. Only parent_node matters, to nest a node inside a forEach. Before building the graph, load the epinium-workflow-builder skill (and its mcp.md reference) with epinium_get_skill: it covers which collection to read and how to compute metrics such as ACOS, which validation does not check.
epinium_delete_cluster
ChatGPTDeletes ONE keyword cluster of the account. This cannot be undone: there is no bin, and its keywords and product list are lost. Ask the user before calling it. Nothing is sent to Amazon, but the cluster stops feeding the SEO prompts, the keyword discovery of the optimizer and the cluster filter of the product charts. It is refused with 409, and nothing is deleted, when the person protected the cluster in the Epinium app or when a smart campaign uses it as its base cluster: the error names those smart campaigns, which have to be changed or deleted first. To only take keywords or products out, use epinium_update_cluster instead. Pass idempotency_key and reuse it on retries.
epinium_delete_workflow
ChatGPTDeletes a workflow of the account and everything under it: its execution history, the payloads of those executions and its version snapshots. There is no undo and no bin — once gone, the record of what the workflow did is gone with it, so confirm with the person before calling this. Pausing is almost always what is actually wanted: epinium_update_workflow with active: false stops it running tonight and keeps everything it already did.
epinium_estimate_workflow_cost
ChatGPTThe forecast the app shows in the workflow detail, read WITHOUT running anything. Check it before epinium_run_workflow with dry_run: false on any workflow that walks a catalogue: the cost scales with the items inside each forEach, so a graph of a dozen nodes can still be expensive on a large account. A row closes exactly: estimated_items x tokens_per_item + loop_tokens = estimated_tokens. Do NOT multiply by billable_nodes_per_item, which counts the nodes rather than pricing them - a create-task does not cost the same as a plain action. What the total is worth depends on one flag: with every row forecastable: true it is an UPPER bound, because it counts the items matching today and a run may process fewer. But a row with forecastable: false is a loop whose size cannot be known until the run happens, and its cost is left OUT - so with any such row the total is NOT an upper bound, it is incomplete, and the real cost can exceed it. A zero there means "not forecast", never "free". A platform-request node is priced at its fixed part only: it also costs 1 credit per KB of the store response, added when it runs, because the size is not known before.
epinium_find_data
ChatGPTFinds which Epinium tool, field or parameter holds a piece of data, by its name, acronym or a synonym in English or Spanish: BSR or sales rank, ACoS, TACoS, ROAS, CTR, CPC, CVR or conversion rate, Buy Box, price or PVP, margin, Amazon fees, refunds and returns, stock and days of coverage, sessions, page views, glance views, impressions, clicks, ad spend, bids, keywords, search terms, clusters, category, B2B, new-to-brand. It answers from the catalog of this server, not from account data: it is free, costs no credits and needs no dates. Call it BEFORE telling the person that a metric is not available, and whenever you do not know which tool to search for. It returns the matching tools with the exact field or parameter name and its caveats, plus how to get what is not a single field (TACoS, totals, trends). For totals, breakdowns or monthly series of any metric the answer is group_by and granularity on the metrics tools, never paging and summing rows.
epinium_get_adgroup
ChatGPTAd groups of the authenticated account's advertising campaigns. Fetches a single adgroup by its id. Related records can be inlined with expand: connection, country, campaign (nested paths like connection.country also work).
epinium_get_amazon_advertising_product
ChatGPTAmazon Advertising products of the authenticated account — the catalog as the Advertising API sees it, including its bestSellerRank (BSR) and categoryName. Use it when relating advertising entities back to a product. Fetches a single amazon advertising product by its id. Related records can be inlined with expand: connection, country, brand (nested paths like connection.country also work).
epinium_get_amazon_seller_product
ChatGPTAmazon Seller Central listings of the authenticated account. Use it instead of products when the question is specifically about Seller Central data. expand=salesRanks returns the category behind each Best Seller Rank (BSR) (browse node id, category title and rank, plus the top-level display group), without loading the whole catalogPublicInfo. The BSR over time is rank in epinium_list_seller_product_metrics. Fetches a single amazon seller product by its id. Related records can be inlined with expand: connection, country, brand (nested paths like connection.country also work). Large raw payloads are omitted by default to keep responses small; request them explicitly with expand: sellerCentralInfo, catalogPublicInfo, pricing, buyboxB2C, buyboxB2B, fbaInventory, aplusContent, competitivePriceSummary, suppressed, fbaLocalStock, salesRanks.
epinium_get_amazon_vendor_product
ChatGPTAmazon Vendor Central listings of the authenticated account. Use it instead of products when the question is specifically about Vendor Central data. expand=salesRanks returns the category behind each Best Seller Rank (BSR) (browse node id, category title and rank, plus the top-level display group), without loading the whole catalogPublicInfo. expand=customerFeedback returns what customers say, as Amazon summarises it: the ten most common positive and negative review topics of the ASIN and of its whole category (with their impact on the star rating, six-month trends and verbatim quotes), and the most common return reasons of its category (Amazon does not give return reasons per ASIN). It is a current snapshot with its snapshotDate, not a history, and null for products Amazon has no topics for. Fetches a single amazon vendor product by its id. Related records can be inlined with expand: connection, country, brand (nested paths like connection.country also work). Large raw payloads are omitted by default to keep responses small; request them explicitly with expand: vendorCentralInfo, catalogPublicInfo, aplusContent, inventory, salesRanks, customerFeedback.
epinium_get_campaign
ChatGPTAmazon Advertising campaigns of the authenticated account. The top of the advertising hierarchy: campaign → ad group → target / product ad. Each campaign carries its daily or lifetime budget with the currency, and — for Sponsored Products — its dynamic bidding strategy: fixed (MANUAL), down-only (LEGACY_FOR_SALES) or up-and-down (AUTO_FOR_SALES). Read it before proposing bid changes: up-and-down lets Amazon raise the bid, so real spend runs above the base bid. Sponsored Brands and Display have no bidding strategy and return null. Fetches a single campaign by its id. Related records can be inlined with expand: connection, country (nested paths like connection.country also work). Epinium's own optimization settings (target ACOS or ROAS, bid floor and ceiling, monthly budget, and which workflows manage the campaign) are omitted by default; request them with expand: optimizationConfig.
epinium_get_campaign_optimization_history
ChatGPTWhat the automation actually CHANGED on one campaign, aggregated to a net per entity. Only applied changes, and only real ones — a dry-run simulation never appears here. Each row is a target whose bid was moved, and it carries the bid from before the first change against the bid after the last one, so a target raised and then capped back down reports direction: unchanged with change_count: 2. That reading is the point of this tool: a flat list of decisions shows a raise and a lower without showing that they cancel out. Proposals are excluded too — the optimizer computes a bid that the economic ceiling can then cut, so only what reached Amazon is reported. Non-bid changes (harvested keywords, negatives, placement adjustments, blocked or quarantined targets) have no previous bid to compare, so they are counted in other_changes instead of padding the table with nulls. Pair it with epinium_list_campaign_metrics over the same window to judge whether the changes helped: this tool says what was done, the metrics say what it achieved. The window defaults to the last 90 days and cannot exceed 90, which is how long these records are kept.
epinium_get_cluster
ChatGPTKeyword clusters of the authenticated account: groups of products that share a keyword strategy, used by Epinium's SEO and advertising tooling. By default each cluster returns productCount only; add expand[]=products to get the product ids (or the full product objects). Fetches a single cluster by its id. Related records can be inlined with expand: products (nested paths like connection.country also work).
epinium_get_connection
ChatGPTData source connections of the authenticated account. Each connection links Epinium to one Amazon Seller Central, Vendor Central or Advertising account for a set of marketplaces. Start here: almost every other resource filters by connection, and this is how you learn which ids exist. Fetches a single connection by its id. Related records can be inlined with expand: countries (nested paths like connection.country also work).
epinium_get_country
ChatGPTAmazon marketplace countries (ISO 3166 code plus the Amazon marketplace id). A global reference table, identical for every account — use it to resolve the country ids the other resources return. Fetches a single country by its id.
epinium_get_pnl_cascade
ChatGPTSame calculation as the "Cascada del periodo" chart in Rentabilidad: net sales minus fees/logistics, advertising and product cost, with the previous period of equal length for comparison. currency is required, and every amount in the response lands in it (a day without an fx rate falls back to an approximate one, never an error). Free and Guru plans receive the same shape with cogs/product_cost always 0 and includes_product_cost: false. connection and country restrict to a single sales connection/marketplace; without them, every Amazon Seller/Vendor connection this credential can read is summed.
epinium_get_pnl_freshness
ChatGPTHow up to date this P&L is: the last day each native source (amazon_economics, amazon_vendor, amazon_ads, unit_costs) actually has a row for, inside the requested window. Call this BEFORE epinium_get_pnl_cascade or epinium_list_pnl_products for a recent period, to tell a real gap from data that has simply not arrived yet - Amazon Data Kiosk economics lag 48-72h. No currency: nothing here is a monetary amount. On Free/Guru plans unit_costs never appears in sources - same plan gate as includes_product_cost elsewhere.
epinium_get_pnl_product
ChatGPTSame ficha as the product margin section in Rentabilidad: one row per month, with the breakdown by native P&L line (e.g. referral_fee, fba_fulfilment_fee, cogs) inside each category. Scoped to the product's own sales connection and country - there is no connection/country filter here, the id already picks the product. Same currency-conversion rule as epinium_get_pnl_cascade. Fails when id does not exist, is not a catalog product (Seller or Vendor) or falls outside the connections this credential can read - never partial data for a product it cannot see. Free and Guru plans receive the same shape with cogs/product_cost always 0 and includes_product_cost: false.
epinium_get_portfolio
ChatGPTPortfolios of the authenticated account's Amazon Ads accounts, with the budget cap each one puts on ALL its campaigns together. budget.policy is MONTHLY_RECURRING (resets every month), DATE_RANGE (between startDate and endDate) or NO_CAP; budget: null means no cap. inBudget says whether Amazon still considers it within its cap. This is the budget shared by a group of campaigns; a single campaign's own daily budget is the budget field of the campaign resource. Fetches a single portfolio by its id.
epinium_get_product
ChatGPTCatalog products of the authenticated account — Epinium's unified product entity, which merges the seller, vendor and advertising views of the same ASIN. This is the right resource for general catalog questions. Each product also carries its barcodes (EAN, UPC, GTIN), so this is where you find duplicate listings that share a product identifier. Fetches a single product by its id. Related records can be inlined with expand: connection, country, brand (nested paths like connection.country also work).
epinium_get_product_ad
ChatGPTProduct ads of the authenticated account — the link between an ad group and the product it advertises. Fetches a single product ad by its id. Related records can be inlined with expand: connection, country, campaign, adGroup, product (nested paths like connection.country also work).
epinium_get_product_brand
ChatGPTBrands present in the authenticated account's catalog, scoped to it: brands belonging only to other Epinium customers are never returned, and epinium_get_product_brand answers 404 for a brand absent from this catalog. This is the brand-name entity referenced by a product's brand field, not the brand-identity feature of the Epinium app. Fetches a single product brand by its id.
epinium_get_prompt
ChatGPTCustom prompts of the authenticated account (Settings > Prompts in the Epinium app): instructions the AI follows when it writes listing content - tone, structure, words to use or avoid. A prompt changes nothing on Amazon by itself and generates nothing: it is applied when listing content is generated for the products of the keyword clusters it is linked to (the prompts of epinium_get_cluster). fields lists the listing fields it applies to (titleAndHighlights, product_description, bullet_point, generic_keyword); empty means every field. Fetches a single prompt by its id.
epinium_get_search_term
ChatGPTSearch terms the authenticated account's ads were served on — the actual shopper queries, as opposed to the targets that matched them. Fetches a single search term by its id. Related records can be inlined with expand: connection, country, campaign, adGroup (nested paths like connection.country also work).
epinium_get_skill
ChatGPTValidated marketing playbooks for brands and manufacturers: each one carries the method, formulas, thresholds and red flags for a single job. Covers Amazon and Walmart advertising (bids, Max CPC, breakeven and target ACoS, ROAS, budget allocation, search-term harvesting, negative keywords, Sponsored Products/Brands/Display, DSP, dayparting, cannibalization), marketplace and listing work (ASIN listings, A+ brand content, variation families, Buy Box, review mining, FBA restock and reimbursements, aged inventory, GPSR compliance), Google, Meta, TikTok and Criteo ads, Shopify, WooCommerce and Magento stores, and SEO, content, email/CRM, social, influencer, affiliate, PR, creative, analytics and brand strategy. Read the relevant skill before advising on one of these areas: it carries the margin math, cadence and failure modes that generic advice gets wrong. A skill is listed even when the account lacks the connection it needs — read it to find out what to connect. Fetches a single skill by its id.
epinium_get_target
ChatGPTAdvertising targets (keywords and product targets) of the authenticated account, with their current bid and state: this is where bids live. Their performance is in epinium_list_target_metrics. Fetches a single target by its id. Related records can be inlined with expand: connection, country, campaign, adGroup (nested paths like connection.country also work).
epinium_get_task
ChatGPTEpinium tasks of the authenticated account: containers of suggested changes over products, campaigns or targets, created manually, by the AI chat or by a workflow. NOTE: these are Epinium's own tasks, unrelated to the MCP tasks protocol extension for long-running operations. Fetches a single task by its id.
epinium_get_task_item
ChatGPTIndividual suggestions inside an Epinium task: the entity they touch, the problem detected, the current value and the suggested one. Fetches a single task item by its id. Related records can be inlined with expand: task (nested paths like connection.country also work).
epinium_get_workflow
ChatGPTAutomation workflows of the authenticated account — the rules that adjust bids, budgets, keywords and negatives on the campaigns they process, every night. Use epinium_get_workflow to audit what one is configured to do: it returns the schedule, the node graph, and every configuration variable with its effective value, flagging which ones the customer overrode versus which still carry the template default. Tell workflow types apart by description_key, NOT by name — several templates share a display name. Note that schedule.last_run_at advances even when a run was skipped (inactive account, missing tokens), so a recent timestamp is not proof that work happened. Fetches a single workflow by its id.
epinium_get_workflow_node_types
ChatGPTEverything the workflow engine understands, so you can build a graph instead of copying one: the node types and what each is for, which fields their data needs and which the server fills in for you, the actions a node can run, the operators a condition accepts, and what a forEach can iterate over. Read this BEFORE epinium_create_workflow - without it the only way to learn the shape is to read an existing workflow and infer, and an account with no workflow of the kind you need leaves you guessing. Actions come grouped: general are the building blocks; campaign-optimizer are the internals of Epinium's own bid optimizer, a chain with a required order and shared state, not parts to assemble by hand.
epinium_get_workflow_performance
ChatGPTAdvertising results of the campaigns a workflow processes, over a required start_date/end_date window. This is how you judge whether a workflow is working: each row puts the configured objective_type/objective_value next to the realized ACOS, ROAS, spend, orders and conversion rate, so the target and the outcome can be compared directly. optimizing_since is when the workflow first touched that campaign for real — results before that date are NOT its doing, so a window straddling it will mislead you. Monetary amounts are decimal strings; ratios are fractions (0.1642 = 16.42%) and are null, never 0, when their denominator is zero.
epinium_get_workflow_version
ChatGPTThe full graph as it was when that version was saved, in the same shape epinium_get_workflow returns, so comparing what is live against what would come back needs no translation. Read this before restoring — it is the only way to see what the workflow would become.
epinium_instantiate_workflow_template
ChatGPTCreates the account's own copy of a template, PAUSED, with the template's graph, variables and schedule already in place. It stays paused until somebody turns it on with epinium_update_workflow and active: true — confirm that with the person first, because from then on it moves real bids every night. Instantiating the same template twice is allowed and gives two independent copies, so check what the account already has before calling: epinium_list_workflows with template set to the template id returns the copies that came from it. To duplicate a workflow the account ALREADY has, use epinium_clone_workflow instead — that one copies its current configuration, not the template defaults.
epinium_list_accounts
ChatGPTLists the Epinium accounts this agency API key can operate on, with their names and the connections it reaches on each. Use it to pick the account_id the data tools require.
epinium_list_adgroup_metrics
ChatGPTAdvertising performance per ad group: spend, sales, ACOS, ROAS, CTR, CPC, clicks and impressions over a date range. One level below campaign_metrics: use it to find which ad groups inside a campaign carry the spend. start_date and end_date are REQUIRED. Use order_by (cost, sales, acos…) with limit to get a top-N directly instead of paging through everything. Use group_by (account, connection, country) for the account-level spend instead of paging through ad groups and summing; rows then stay split by currency and ad_product. Monetary amounts are decimal strings; ratios are fractions (0.16 = 16%). With include_total=true, total_count counts entities (or groups with group_by), and, with any granularity other than total (daily, weekly, monthly, quarterly, yearly), each of their periods that has data, not entities times periods. Returns an offset-paginated list, with no cursor: page by advancing offset by limit while has_more is true.
epinium_list_adgroups
ChatGPTAd groups of the authenticated account's advertising campaigns. Filter by campaign to drill down from a campaign, or by connection, country or state; search matches the ad group name. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: connection, country, campaign (nested paths like connection.country also work).
epinium_list_advertising_changes
ChatGPTEvery change Epinium pushed to Amazon for this account, newest first: bid, budget, state, name and bidding-strategy changes on campaigns, ad groups, targets and product ads, plus the entities it created. One row per entity actually sent, including the ones Amazon REJECTED, which carry result: "failed" and the Amazon message in error - so this is where to look when a change did not take effect. source says where it came from (front the Epinium app, workflow the optimizer, system an internal job, public-api/mcp this channel) and actor who did it. Do NOT confuse it with get_campaign_optimization_history, which explains WHY the optimizer decided something: this one says WHAT was touched and whether Amazon accepted it. The two join on correlation_id. Filter by campaign, adgroup, entity, entity_type, source, result, field or correlation_id, and narrow the window with start_date / end_date (both YYYY-MM-DD, inclusive). Returns a cursor-paginated list; follow has_more with starting_after to page.
epinium_list_amazon_advertising_products
ChatGPTAmazon Advertising products of the authenticated account — the catalog as the Advertising API sees it, including its bestSellerRank (BSR) and categoryName. Use it when relating advertising entities back to a product. Filter by connection, country, brand or asin, or search across title, ASIN and SKU. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: connection, country, brand (nested paths like connection.country also work).
epinium_list_amazon_seller_products
ChatGPTAmazon Seller Central listings of the authenticated account. Use it instead of products when the question is specifically about Seller Central data. expand=salesRanks returns the category behind each Best Seller Rank (BSR) (browse node id, category title and rank, plus the top-level display group), without loading the whole catalogPublicInfo. The BSR over time is rank in epinium_list_seller_product_metrics. Filter by connection, country, brand or asin, or search across title, ASIN and SKU. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: connection, country, brand (nested paths like connection.country also work). Large raw payloads are omitted by default to keep responses small; request them explicitly with expand: sellerCentralInfo, catalogPublicInfo, pricing, buyboxB2C, buyboxB2B, fbaInventory, aplusContent, competitivePriceSummary, suppressed, fbaLocalStock, salesRanks.
epinium_list_amazon_vendor_products
ChatGPTAmazon Vendor Central listings of the authenticated account. Use it instead of products when the question is specifically about Vendor Central data. expand=salesRanks returns the category behind each Best Seller Rank (BSR) (browse node id, category title and rank, plus the top-level display group), without loading the whole catalogPublicInfo. expand=customerFeedback returns what customers say, as Amazon summarises it: the ten most common positive and negative review topics of the ASIN and of its whole category (with their impact on the star rating, six-month trends and verbatim quotes), and the most common return reasons of its category (Amazon does not give return reasons per ASIN). It is a current snapshot with its snapshotDate, not a history, and null for products Amazon has no topics for. Filter by connection, country, brand or asin, or search across title, ASIN and SKU. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: connection, country, brand (nested paths like connection.country also work). Large raw payloads are omitted by default to keep responses small; request them explicitly with expand: vendorCentralInfo, catalogPublicInfo, aplusContent, inventory, salesRanks, customerFeedback.
epinium_list_campaign_metrics
ChatGPTAdvertising performance per campaign: spend, sales, ACOS, ROAS, CTR, CPC, clicks and impressions over a date range. Answers "how much am I spending per campaign?" and "which campaigns have the worst ACOS?". start_date and end_date are REQUIRED. Use order_by (cost, sales, acos…) with limit to get a top-N directly instead of paging through everything. Use group_by (account, connection, country) for the account-level spend instead of paging through campaigns and summing; rows then stay split by currency and ad_product. Monetary amounts are decimal strings; ratios are fractions (0.16 = 16%). With include_total=true, total_count counts entities (or groups with group_by), and, with any granularity other than total (daily, weekly, monthly, quarterly, yearly), each of their periods that has data, not entities times periods. Returns an offset-paginated list, with no cursor: page by advancing offset by limit while has_more is true.
epinium_list_campaigns
ChatGPTAmazon Advertising campaigns of the authenticated account. The top of the advertising hierarchy: campaign → ad group → target / product ad. Each campaign carries its daily or lifetime budget with the currency, and — for Sponsored Products — its dynamic bidding strategy: fixed (MANUAL), down-only (LEGACY_FOR_SALES) or up-and-down (AUTO_FOR_SALES). Read it before proposing bid changes: up-and-down lets Amazon raise the bid, so real spend runs above the base bid. Sponsored Brands and Display have no bidding strategy and return null. Filter by connection, country or state, or search by campaign name. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: connection, country (nested paths like connection.country also work). Epinium's own optimization settings (target ACOS or ROAS, bid floor and ceiling, monthly budget, and which workflows manage the campaign) are omitted by default; request them with expand: optimizationConfig.
epinium_list_clusters
ChatGPTKeyword clusters of the authenticated account: groups of products that share a keyword strategy, used by Epinium's SEO and advertising tooling. By default each cluster returns productCount only; add expand[]=products to get the product ids (or the full product objects). search matches the cluster name and its positive and negative keywords. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: products (nested paths like connection.country also work).
epinium_list_connections
ChatGPTData source connections of the authenticated account. Each connection links Epinium to one Amazon Seller Central, Vendor Central or Advertising account for a set of marketplaces. Start here: almost every other resource filters by connection, and this is how you learn which ids exist. Filter by type, or search by connection name. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: countries (nested paths like connection.country also work).
epinium_list_countries
ChatGPTAmazon marketplace countries (ISO 3166 code plus the Amazon marketplace id). A global reference table, identical for every account — use it to resolve the country ids the other resources return. Filter by code. Returns a cursor-paginated list; follow has_more with starting_after to page.
epinium_list_platform_changes
ChatGPTEvery write Epinium sent to a connected Shopify or WooCommerce store for this account, newest first: one row per write sent through POST /v1/platform-request - epinium_platform_request included - that reached the store. Each row carries the operation (the Shopify mutation, or the WooCommerce method and route), the ids of the entities it touched, the request as sent, what the store answered, and result: applied, rejected (the store refused it, with its reasons in provider_errors) or unknown (it reached the store and no reliable answer came back). This is where to check what a write whose answer was lost did, and what a WooCommerce delete removed - the deleted object is in the answer; a Shopify delete keeps no copy. There is no previous value: it says WHAT was sent, not what it replaced. source says whether it came through the API or the MCP, and actor which credential. Filter by connection, platform, operation, result, entity_id, source or correlation_id, and narrow the window with start_date / end_date (both YYYY-MM-DD, inclusive). Returns a cursor-paginated list; follow has_more with starting_after to page.
epinium_list_pnl_ads_matrix
ChatGPTSame breakdown as the advertising matrix in the channel card of Rentabilidad: one row per sales connection and ad platform combination (only amazon_ads exists today), each with its spend against that connection's net sales. No limit/offset, same reasoning as epinium_list_pnl_channels. Same currency-conversion rule as epinium_get_pnl_cascade. NOT plan-gated: advertising spend is part of the pre-COGS P&L every plan already sees via epinium_list_seller_product_metrics/epinium_list_vendor_product_metrics, so there is no includes_product_cost field here.
epinium_list_pnl_channels
ChatGPTSame per-connection breakdown as the channel card in Rentabilidad: one row per sales connection (Amazon Seller or Vendor), ordered by net sales. No limit/offset: the row count is bounded by the sales connections this credential can read, not by catalog size. Same currency-conversion rule as epinium_get_pnl_cascade. Free and Guru plans receive every row with cogs/product_cost at 0 and includes_product_cost: false.
epinium_list_pnl_products
ChatGPTSame per-product breakdown as the "Margen por producto" table in Rentabilidad: one row per catalog product, plus an "unassigned" row (product is null) for sales that could not be matched to one. Same currency-conversion rule as epinium_get_pnl_cascade: currency is required. Paginates with limit/offset, not a cursor - rows are aggregates with no id of their own. order_by picks the sort field (default net sales); search matches the catalog title, then filters by the matched SKUs/ASINs. Free and Guru plans receive every row with cogs/product_cost at 0 and includes_product_cost: false.
epinium_list_portfolios
ChatGPTPortfolios of the authenticated account's Amazon Ads accounts, with the budget cap each one puts on ALL its campaigns together. budget.policy is MONTHLY_RECURRING (resets every month), DATE_RANGE (between startDate and endDate) or NO_CAP; budget: null means no cap. inBudget says whether Amazon still considers it within its cap. This is the budget shared by a group of campaigns; a single campaign's own daily budget is the budget field of the campaign resource. Filter by connection, country or state; search matches the portfolio name. Returns a cursor-paginated list; follow has_more with starting_after to page.
epinium_list_product_ad_metrics
ChatGPTAdvertising performance per product ad: spend, sales, ACOS, ROAS, CTR, CPC, clicks and impressions over a date range, with the ASIN of the advertised product. Answers "which of my advertised products actually convert?". Only Sponsored Products and Sponsored Display have product ads, so ad_product accepts SP and SD only. start_date and end_date are REQUIRED. Use order_by (cost, sales, acos…) with limit to get a top-N directly. Use group_by (account, connection, country or cluster) for the account-level or per-cluster spend instead of paging through product ads and summing; rows then stay split by currency and ad_product. cluster restricts to the advertised ASINs of one or more product clusters (ids from clusters): the ASIN of each clustered product in its own country, across every advertising profile in scope; about 3% of spend has no ASIN and falls outside that filter. Monetary amounts are decimal strings; ratios are fractions (0.16 = 16%). With include_total=true, total_count counts entities (or groups with group_by), and, with any granularity other than total (daily, weekly, monthly, quarterly, yearly), each of their periods that has data, not entities times periods. Returns an offset-paginated list, with no cursor: page by advancing offset by limit while has_more is true.
epinium_list_product_ads
ChatGPTProduct ads of the authenticated account — the link between an ad group and the product it advertises. Filter by campaign, adGroup, product, asin or state, or search across ASIN and SKU. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: connection, country, campaign, adGroup, product (nested paths like connection.country also work).
epinium_list_product_brands
ChatGPTBrands present in the authenticated account's catalog, scoped to it: brands belonging only to other Epinium customers are never returned, and epinium_get_product_brand answers 404 for a brand absent from this catalog. This is the brand-name entity referenced by a product's brand field, not the brand-identity feature of the Epinium app. search matches the brand name. Returns a cursor-paginated list; follow has_more with starting_after to page.
epinium_list_products
ChatGPTCatalog products of the authenticated account — Epinium's unified product entity, which merges the seller, vendor and advertising views of the same ASIN. This is the right resource for general catalog questions. Each product also carries its barcodes (EAN, UPC, GTIN), so this is where you find duplicate listings that share a product identifier. Filter by connection, country, brand or asin, or search across title, ASIN and SKU. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: connection, country, brand (nested paths like connection.country also work).
epinium_list_prompts
ChatGPTCustom prompts of the authenticated account (Settings > Prompts in the Epinium app): instructions the AI follows when it writes listing content - tone, structure, words to use or avoid. A prompt changes nothing on Amazon by itself and generates nothing: it is applied when listing content is generated for the products of the keyword clusters it is linked to (the prompts of epinium_get_cluster). fields lists the listing fields it applies to (titleAndHighlights, product_description, bullet_point, generic_keyword); empty means every field. search matches the prompt name. Returns a cursor-paginated list; follow has_more with starting_after to page.
epinium_list_search_term_metrics
ChatGPTAdvertising performance (spend, sales, ACOS, ROAS, CTR, CPC) per shopper search term, with the actual query text resolved from the catalog into query: the text is NOT in the report store at all. Answers "which searches do I spend most on?" and is the input for harvest and negative-keyword decisions; rows are grouped per search term AND target, because the same text can be matched by different targets. Only Sponsored Products and Sponsored Brands produce search terms, so ad_product accepts SP and SB only. start_date and end_date are REQUIRED, and this is the heaviest resource in the API: window capped at 93 days, or 31 with granularity=daily. Use order_by=cost with limit instead of paging. Use group_by (account, connection, country) for the account-level spend instead of paging through search terms and summing; rows then stay split by currency and ad_product. With include_total=true, total_count counts entities (or groups with group_by), and, with any granularity other than total (daily, weekly, monthly, quarterly, yearly), each of their periods that has data, not entities times periods. Returns an offset-paginated list, with no cursor: page by advancing offset by limit while has_more is true.
epinium_list_search_terms
ChatGPTSearch terms the authenticated account's ads were served on — the actual shopper queries, as opposed to the targets that matched them. Filter by campaign, adGroup or searchTerm (exact), or search for a substring of the query text. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: connection, country, campaign, adGroup (nested paths like connection.country also work).
epinium_list_seller_product_metrics
ChatGPTSeller Central performance per product over a date range: sales, units, orders, sessions, page views, Buy Box percentage, conversion rate (CVR), Best Seller Rank (BSR, field rank), Amazon fees, net sales, margin before ads, refunds, stock, days of coverage, price and Amazon Business (B2B) sales. start_date and end_date are REQUIRED. For an account total, a breakdown (country, connection or product cluster), or a monthly series, use group_by and granularity in ONE call instead of paging through products and adding them up. For a top-N, order_by (sales, units, orders, sessions, page_views, rank, conversion_rate, net_sales, amazon_fees, margin_before_ads, days_of_coverage, b2b_sales) with limit; order_by=days_of_coverage&order=asc gives the products about to run out of stock. cluster restricts to the products of one or more product clusters. Rows are per ASIN + SKU + connection + country + currency, and amounts are decimal strings in their own currency, never converted. rank is the median BSR of the window and carries no category: the category comes with expand=salesRanks on epinium_list_amazon_seller_products, which is also where the listing itself lives. Traffic fields and rank are null, never 0, when Amazon did not report them. The economics fields (referral_fee, fba_fulfilment_fee, storage_fee, other_fees, amazon_fees, net_sales, net_units, margin_before_ads, refunded_sales, refunded_units) exclude VAT while sales includes it, so never subtract fees from sales; they include no advertising, margin_before_ads is not profit, and they are null until Amazon delivers them (48-72 h). stock and days_of_coverage are null under group_by unless it includes country. For the full caveats of any field, call epinium_find_data with its name. Returns an offset-paginated list, with no cursor: page by advancing offset by limit while has_more is true.
epinium_list_skills
ChatGPTValidated marketing playbooks for brands and manufacturers: each one carries the method, formulas, thresholds and red flags for a single job. Covers Amazon and Walmart advertising (bids, Max CPC, breakeven and target ACoS, ROAS, budget allocation, search-term harvesting, negative keywords, Sponsored Products/Brands/Display, DSP, dayparting, cannibalization), marketplace and listing work (ASIN listings, A+ brand content, variation families, Buy Box, review mining, FBA restock and reimbursements, aged inventory, GPSR compliance), Google, Meta, TikTok and Criteo ads, Shopify, WooCommerce and Magento stores, and SEO, content, email/CRM, social, influencer, affiliate, PR, creative, analytics and brand strategy. Read the relevant skill before advising on one of these areas: it carries the margin math, cadence and failure modes that generic advice gets wrong. A skill is listed even when the account lacks the connection it needs — read it to find out what to connect. Filter by integration (amazon, google, shopify…) or division, or search across name and description. Returns a list; has_more tells whether another page follows.
epinium_list_target_metrics
ChatGPTAdvertising performance (spend, sales, ACOS, ROAS, CTR, CPC) per target - keyword, product or category - with the target type and keyword resolved from the catalog. Answers "which keywords waste my budget?"; ClickHouse alone cannot tell you, because the keyword text is only reliable in the catalog. start_date and end_date are REQUIRED, and this resource has a SHORTER window cap than the others: 93 days, or 31 with granularity=daily. Use order_by (cost, sales, acos…) with limit to get a top-N directly. Use group_by (account, connection, country) for the account-level spend instead of paging through targets and summing; rows then stay split by currency and ad_product. Monetary amounts are decimal strings; ratios are fractions (0.16 = 16%). With include_total=true, total_count counts entities (or groups with group_by), and, with any granularity other than total (daily, weekly, monthly, quarterly, yearly), each of their periods that has data, not entities times periods. Returns an offset-paginated list, with no cursor: page by advancing offset by limit while has_more is true.
epinium_list_targets
ChatGPTAdvertising targets (keywords and product targets) of the authenticated account, with their current bid and state: this is where bids live. Their performance is in epinium_list_target_metrics. Filter by campaign or adGroup to drill down, and by targetType, state or negative to separate positive targeting from negatives. search matches the target's text (keyword, ASIN or category, by targetType) and its matchType; with targetType set, only that type's field is searched. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: connection, country, campaign, adGroup (nested paths like connection.country also work).
epinium_list_task_items
ChatGPTIndividual suggestions inside an Epinium task: the entity they touch, the problem detected, the current value and the suggested one. Filter by task to read one task's suggestions, or by entityModel / status; search matches the display name, display id and problem label. Returns a cursor-paginated list; follow has_more with starting_after to page. Related records can be inlined with expand: task (nested paths like connection.country also work).
epinium_list_tasks
ChatGPTEpinium tasks of the authenticated account: containers of suggested changes over products, campaigns or targets, created manually, by the AI chat or by a workflow. NOTE: these are Epinium's own tasks, unrelated to the MCP tasks protocol extension for long-running operations. Filter by status or priority, or search by title. Returns a cursor-paginated list; follow has_more with starting_after to page.
epinium_list_vendor_product_metrics
ChatGPTVendor Central sales per product over a date range. There is deliberately NO single sales or orders field: read the pair that matches the business model. Manufacturing (Amazon makes the product under licence) reports manufacturing_ordered_sales/_units, manufacturing_shipped_sales/_units/_cogs and manufacturing_net_received_sales/_units; sourcing (you sell wholesale to Amazon) reports only the shipped and net received pairs. Assuming "sales" means sourcing shipped makes a manufacturing vendor read zeros. Also returns units (all ordered units), glance_views (vendor has no sessions and no conversion rate), Best Seller Rank (BSR, field rank: the median of the window, with no category, which comes with expand=salesRanks on epinium_list_amazon_vendor_products), customer returns, the sell-in with Amazon (confirmed and open PO units, fill and confirmation rates, lead time), inventory health (sell-through, out-of-stock rates, aged, unsellable and in-transit units), the two *_sellable_units and days_of_coverage. start_date and end_date are REQUIRED. For an account total, a breakdown (country, connection or product cluster) or a monthly series use group_by and granularity in ONE call instead of paging through products and adding them up. order_by with limit gives a top-N; order_by=days_of_coverage&order=asc lists the products about to run out. cluster restricts to the products of one or more product clusters. Rows are per ASIN + connection + country + currency (the SKU is not part of the key). Rates are fractions (0.95 = 95%); stocks and levels are the latest value of the window, not a sum. glance_views, rank and the stocks are null, never 0, when Amazon did not report them. For the full caveats of any field, call epinium_find_data with its name. Returns an offset-paginated list, with no cursor: page by advancing offset by limit while has_more is true.
epinium_list_workflow_campaigns
ChatGPTThe campaigns a workflow actually processes, with the AI configuration each one carries (objective and its target value, bid limits, budget, whether AI actions are enabled, and since when it has really been optimized). This is NOT simply the campaigns linked to the workflow: membership is decided by three controls stored per campaign (force-include, force-exclude, global opt-out) combined with the workflow's own filter and its auto-selection setting, so every row carries a gate object saying why it is in. When the set comes back empty, empty_reason names the cause — manual-sin-enlaces means the workflow is on manual selection with nothing linked, which is the state a workflow is BORN in and the usual reason one runs nightly for weeks doing nothing; filtro-vacio means no campaign passes its own filter; no-itera-campanas means this workflow does not act on campaigns at all.
epinium_list_workflow_execution_payloads
ChatGPTWhere a workflow's decisions actually are: one row per step of a run, carrying what that step produced. Read THIS, not the run itself, to answer what a workflow decided and why — the run document only keeps the top-level nodes, and in this product the reasoning lives inside the forEach. It takes TWO calls, by design. First call it as-is: with the default data: 'none' you get the index of the run — every step with its label and nothing else. A label starts with the CONTAINER - the forEach the work happened in - then the item, then the node that did it: wf-foreach-targets-item-2-p9747-wf-calc-bid. So label_prefix takes the container, NOT the node at the end. Copy a prefix from the index instead of composing one; if it matches nothing you get an error listing the prefixes that exist, so you are never left guessing. Do not ask for data: 'full' across a whole run of a catalogue-sized workflow: that is millions of characters and it overflows what this conversation can hold, which is why it is not the default. type: 'nodeResult' separates a node's own decision from the engine's scaffolding.
epinium_list_workflow_executions
ChatGPTWhat the workflow has actually done, run by run, newest first. status is how you read the outcome, and partial is its own result rather than a shade of the other two: the graph finished but some items inside a forEach failed and the rest carried on, so neither "it all worked" nor "nothing happened" is true. Filter dry_run before drawing any conclusion from a series — a simulation walks the whole graph but writes nothing, so mixing the two inflates the count of work done. A recent run here is also the honest check on schedule.last_run_at, which advances even when a run was skipped.
epinium_list_workflow_templates
ChatGPTThe catalogue of automations Epinium publishes - the ready-made workflows an account can adopt, filtered to the ones this account is entitled to. These are NOT workflows of the account and they do nothing: they are what a workflow can be created FROM. Use epinium_instantiate_workflow_template to give the account its own copy. Tell them apart by description_key, not name: several share a display name. Returns a list; has_more tells whether another page follows.
epinium_list_workflow_versions
ChatGPTEvery create, clone, instantiation and edit leaves a version behind, and so does a restore. author is what separates a change made by an integration from one made by hand in Epinium. Note that versions EXPIRE: a short list on an old workflow does not mean nobody touched it. The graph is not in these rows — read one version to see it.
epinium_list_workflows
ChatGPTAutomation workflows of the authenticated account — the rules that adjust bids, budgets, keywords and negatives on the campaigns they process, every night. Use epinium_get_workflow to audit what one is configured to do: it returns the schedule, the node graph, and every configuration variable with its effective value, flagging which ones the customer overrode versus which still carry the template default. Tell workflow types apart by description_key, NOT by name — several templates share a display name. Note that schedule.last_run_at advances even when a run was skipped (inactive account, missing tokens), so a recent timestamp is not proof that work happened. search matches the workflow name and description. Returns a cursor-paginated list; follow has_more with starting_after to page.
epinium_platform_docs
ChatGPTReturns, for one platform connected to this account (Shopify over GraphQL, WooCommerce over REST), the API version this proxy is pinned to, two links into that version's reference documentation, the pitfalls that make a request return HTTP 200 with data that looks correct and is not, and the rules epinium_platform_request enforces before any call reaches the provider - allowed routes and parameters, pagination budget, personal data, what the response withholds and, with write access, how to write. Call it before writing a request, not after a rejection. Pass types on Shopify, which is GraphQL (comma-separated, at most 8, e.g. Product,ProductVariant), to get those types as the store reports them RIGHT NOW: their kind and fields (type, deprecation, whether a field is a paginated connection - only those accept first/last - and whether the proxy refuses it as personal data), enumValues or inputFields. A type comes back null only when it does not exist: you misspelled or invented it. granted_scopes lists the scopes the store granted: necessary, not sufficient, since customer data sits behind a second approval no API reports. Pass resources on WooCommerce, which is REST (comma-separated, at most 8, like the path of a request, e.g. products,reports/sales), to get each route as the store describes it RIGHT NOW: its fields (the names for _fields, without meta_data and post_password, which this proxy never serves) and the args its GET accepts in params, with their limits. A resource comes back negative in two ways, fixed in opposite directions. null: the store answered that this route does not exist on it, so correct or drop the path. { allowed: false }: the route is outside the allow-list of this proxy and is refused on every store, so another connection will not open it. types on WooCommerce, or resources on Shopify, is a 400. Without either it returns the static documentation only, and this server does not fetch the two URLs.
epinium_platform_request
ChatGPTCall epinium_platform_docs first: it names the API version this proxy is pinned to for the platform, where its reference documentation lives, and the pitfalls that make a request return HTTP 200 with data that looks correct and is not. Reads, and with this credential also creates, edits and DELETES, catalog and content in a store connected to this account, directly and with no human approval in between. Shopify (platform: "shopify") is GraphQL: the document in query with its variables, where a query reads and a mutation writes. WooCommerce (platform: "woocommerce") is REST: the resource in path, its filters in params, and method GET (the default) reads while POST, PUT, PATCH or DELETE write the JSON object in body. Mixing the fields of the two protocols is a 400 shape_mismatch. Confirm with the person anything they did not ask for explicitly. Every write needs idempotency_key - REUSE the same value when you retry the same change, or a timeout turns one write into two. DELETES CANNOT BE UNDONE: Epinium keeps no copy of what a delete removed. On WooCommerce a DELETE with params: { force: true } is permanent, and without force a product goes to the trash; some Shopify arguments delete as well, and the docs name them. A write's answer carries result: applied means the store made the change, rejected that it changed nothing, with the reasons in provider_errors. A 502 provider_result_unknown means the change MAY HAVE BEEN MADE: read the store before anything else, and if it is not there, retry with a NEW idempotency_key - the old one replays that same 502 for 24 hours. What the proxy refuses before calling the store - the WooCommerce allow-list of routes (catalog, reports and reference data: no orders or customers), parameter limits, the Shopify field budget, personal data and, with write access, the write rules - comes back with epinium_platform_docs for the platform, each with the code its rejection carries.
epinium_resolve_task
ChatGPTMarks ONE task as resolved or discarded. This is TERMINAL and is not undone from this API: the task leaves the pending list and the products stop pointing at it. Its pending suggestions are NOT resolved - they stay pending and become frozen, because a suggestion inside a closed task can no longer be approved or rejected. So resolve the suggestions you care about FIRST, and close the task after. Ask the user before discarding: it throws away suggestions they may not have read. Pass idempotency_key.
epinium_restore_workflow_version
ChatGPTReplaces the live graph with the one from a saved version. Restoring IS editing, so the same rule applies: a workflow that can fire on its own is refused with 409 — pause it with epinium_update_workflow and active: false, restore, check the result, then turn it back on. Read the version first with epinium_get_workflow_version: this replaces the graph wholesale and you should be able to tell the person what changes. The state being replaced is saved first, so a restore can itself be undone.
epinium_run_workflow
ChatGPTQueues an execution and returns its id — it does NOT wait for the run to finish, so do not read the result in the same breath: a run over dozens of campaigns takes far longer than a tool call. Use epinium_list_workflow_executions and epinium_list_workflow_execution_payloads afterwards to see what it did. dry_run is REQUIRED and has no default, deliberately: with true the graph runs end to end and writes nothing, with false it moves real bids and budgets on Amazon and writes to any connected store the workflow touches — which one you meant must never depend on a field you forgot, so confirm a real run with the person first. A PAUSED workflow can still be simulated, and that is the point: check it before turning it on, rather than turning it on to check it. The real run is the other way round: it REQUIRES the workflow to be active, and a paused one is rejected with a 400 telling you to activate it first - so dry_run: false on something paused changes nothing and costs nothing.
epinium_update_adgroup
ChatGPTChanges the state, default bid or name of ONE ad group. Send only what you want to change; what you omit stays as it is, and at least one field is required. defaultBid is checked against the marketplace limits before it is sent, so an out-of-range bid comes back telling you the range instead of a generic rejection. An ad group managed by the optimizer is refused - change it from the smart campaign instead. If Amazon rejects the change you still get a result with result: "failed" and the reason, so do not read a response as success without looking at that field. Pass idempotency_key and reuse it on retries. To move many bids at once use the batch tool.
epinium_update_adgroups_batch
ChatGPTChanges state, default bid or name on up to 1000 ad groups in ONE call. Prefer this over calling the single update in a loop - this is the tool for a bid sweep. It is NOT all-or-nothing: you get one row per ad group you sent, and applied counts what actually reached Amazon, so check it. An ad group counts as applied only if EVERY field you asked for went through. Pass idempotency_key and reuse the same value if you retry the same intent.
epinium_update_campaign
ChatGPTChanges the state, daily budget, name or portfolio of ONE campaign. portfolioId takes the Amazon id of a portfolio of the same advertising account (the portfolioId of epinium_list_portfolios), and null takes the campaign out of its portfolio. Send only what you want to change; what you omit stays as it is, and at least one field is required. A campaign managed by the optimizer is refused, because its 03:00 UTC run would overwrite you - change it from the smart campaign instead. If Amazon rejects the change you still get a result with result: "failed" and the reason, so do not read a response as success without looking at that field. Pass idempotency_key and reuse it on retries. To move many campaigns at once use the batch tool: it is one call instead of fifty.
epinium_update_campaign_optimization_config
ChatGPTSets what Epinium's own optimizer chases for ONE campaign: target ACOS or ROAS, bid floor and ceiling, monthly budget, harvesting overrides, and which workflows may touch it. Send only what you want to change; what you omit stays as it is - except harvesting.crossCampaign, which is REPLACED whole: sending {enabled: true} alone wipes harvestGroupKey and role, the two fields cross-harvest uses to find a campaign's peers, so resend them with it. Read the current values with epinium_get_campaign and expand: optimizationConfig. None of this reaches Amazon directly - it is the configuration the optimizer reads, so no idempotency_key is needed here, and budget.dailyBudget here is NOT the Amazon daily budget: it is the pacing anchor the optimizer spends against. The campaign's real Amazon budget is the budget field of the campaign resource itself, changed with epinium_update_campaign. What puts a campaign under the optimizer is `linkedWorkflowDefinitionIds`: a workflow listed there processes it every night and moves real bids on Amazon - confirm it with the person first, exactly as you would turning a workflow on. A workflow that selects campaigns on its own can also pick it up, and workflowsOptOut: true declines that; excludedWorkflowDefinitionIds always keeps a workflow away and wins over the other two. aiEnabled is NOT that switch: it records the account holder consent, goes to Amazon as the epinium:ai_enabled tag and makes the campaign eligible as a cross-harvest peer, so aiEnabled: false does NOT take a campaign out of the optimizer - to stop it, clear linkedWorkflowDefinitionIds (plus workflowsOptOut: true if the workflow selects campaigns on its own) or add the workflow to excludedWorkflowDefinitionIds. optimizeDate and optimizingSince are read-only, stamped by the optimizer, and sending either is rejected.
epinium_update_campaigns_batch
ChatGPTChanges state, daily budget, name or portfolio on up to 1000 campaigns in ONE call - the tool to move a set of campaigns into a portfolio, or out of it with portfolioId: null. Prefer this over calling the single update in a loop. It is NOT all-or-nothing: you get one row per campaign you sent, and applied counts what actually reached Amazon - check it, because a partial result is the normal outcome, not an error. A campaign counts as applied only if EVERY field you asked for went through. Pass idempotency_key and reuse the same value if you retry the same intent.
epinium_update_campaigns_optimization_config_batch
ChatGPTSame update as epinium_update_campaign_optimization_config, for up to 1000 campaigns in ONE call. NOT all-or-nothing: data carries one row per campaign you sent, in the order you sent them, and a row that fails validation does not block the others - each campaign is checked against its OWN stored state. Every caveat of the single tool applies to every row: harvesting.crossCampaign is replaced whole, budget.dailyBudget is the optimizer pacing anchor and not the Amazon daily budget, and optimizeDate/optimizingSince are read-only. `linkedWorkflowDefinitionIds` is what puts a campaign under the optimizer, which then moves real bids on Amazon every night - over a whole batch that is the same decision taken N times at once, so confirm it with the person before enrolling one. aiEnabled is NOT that switch either - it is consent and an Amazon tag - so aiEnabled: false does not take these campaigns out of the optimizer.
epinium_update_cluster
ChatGPTChanges ONE cluster by deltas, so you never resend the whole list: addPositiveKeywords / addNegativeKeywords add keywords (or update the language, score and purpose of a keyword that is already there, matched by text), removePositiveKeywords / removeNegativeKeywords take keywords out by text (unknown texts are ignored), addProducts / removeProducts change which catalog products the cluster groups, and name renames it. Send only what you want to change; at least one field is required. Nothing is sent to Amazon. The resulting lists are capped at 100 positive and 50 negative keywords, a keyword cannot be positive and negative at once, and every product added must be a Seller or Vendor catalog product of the account (type seller or vendor in epinium_list_products, never adv), or the call is refused and nothing changes. A cluster the person has protected in the Epinium app is refused with 409: this API cannot unprotect it, so tell them to do it from Segmentation > Clusters instead of retrying. Pass idempotency_key and reuse it on retries.
epinium_update_portfolio
ChatGPTChanges the name, state or budget cap of ONE portfolio. Send only what you want to change; at least one field is required. budget is REPLACED whole: to raise the amount of a DATE_RANGE cap resend its policy, startDate and endDate too, or Amazon rejects it. Use policy: "NO_CAP" to remove a cap. Lowering a cap can stop the spend of every campaign in the portfolio, so confirm it with the user first. If Amazon rejects the change you get result: "failed" with the reason and nothing changes. Pass idempotency_key and reuse it on retries.
epinium_update_product_ad
ChatGPTState is the only writable field: a product ad links one catalog product to an ad group and has no bid or name of its own. To stop advertising a product, pause its product ad. If Amazon rejects the change you still get a result with result: "failed" and the reason. Pass idempotency_key and reuse it on retries.
epinium_update_product_ads_batch
ChatGPTEnables or pauses up to 1000 product ads in ONE call. Prefer this over calling the single update in a loop. It is NOT all-or-nothing: you get one row per product ad you sent and applied counts what actually reached Amazon. Only applied rows are billed. Pass idempotency_key and reuse the same value if you retry the same intent.
epinium_update_prompt
ChatGPTChanges ONE custom prompt: name, instruction (replaced whole, up to 2,000 characters) or fields (replaces the list; [] means every field). Send only what you want to change; at least one field is required. The previous instruction is not kept anywhere, so read it with epinium_get_prompt first if the person may want it back. Nothing is sent to Amazon and no content is rewritten: the new instruction applies the next time listing content is generated for the products of the clusters the prompt is linked to. Prompts cannot be deleted through this API. Pass idempotency_key and reuse it on retries.
epinium_update_target
ChatGPTChanges the state or bid of ONE target. Send only what you want to change; at least one field is required. Only state and bid are editable: what defines a target - its keyword, its ASIN, its match type - cannot be changed on Amazon, so to change that create another and archive this one. A negative target has no bid and asking for one is refused. bid is checked against the marketplace limits before it is sent. If Amazon rejects the change you still get a result with result: "failed" and the reason. Pass idempotency_key and reuse it on retries. For more than one bid use the batch tool.
epinium_update_targets_batch
ChatGPTTHIS is the tool for a bid sweep: up to 1000 targets in ONE call, each with its own bid. Never call the single update in a loop to move bids - use this. It is NOT all-or-nothing: you get one row per target you sent and applied counts what actually reached Amazon, so check it rather than assuming the whole batch went through. Only applied rows are billed. Pass idempotency_key and reuse the same value if you retry the same intent.
epinium_update_task
ChatGPTChanges the title, description, priority or expiry date of ONE task. Send only what you want to change; what you omit stays as it is, and at least one field is required. It does NOT resolve the task and does NOT touch its suggestions. Pass idempotency_key and reuse it on retries.
epinium_update_task_item
ChatGPTApproves or rejects ONE suggestion inside a task, optionally with your own corrected value in appliedValue instead of the suggested one. Approving does NOT apply the change: use the apply tool on the task afterwards. And a suggestion that nothing knows how to apply - no fieldPath, or a campaign field other than dailyBudget, state or name - is a review note, not a change: the response carries autoApplySkipped: true for those, and approving them records the decision and nothing else. Pass idempotency_key.
epinium_update_task_items_batch
ChatGPTApproves or rejects up to 1000 suggestions in ONE call, EACH WITH ITS OWN decision - prefer it over calling the single one in a loop. It is NOT all-or-nothing: you get one row per suggestion you sent, and applied counts what was actually recorded, so check it. Approving does not apply anything; use the apply tool on the task afterwards. Pass idempotency_key and reuse the same value if you retry the same intent.
epinium_update_workflow
ChatGPTEdits a workflow, and is also how you turn one on and off. Sending active: false on its own ALWAYS works, even on a scheduled workflow — pausing can only make less happen on Amazon. Editing the GRAPH of a scheduled one is refused with 409: its next run moves real bids, and a graph nobody has reviewed should not be what executes, so pause it first (you can do that yourself now) and edit it after. Sending active: true turns it on, and from that point its schedule fires for real every night — confirm with the person before doing it. Setting schedule only records WHEN it would run: it does not turn the workflow on. dry_run: true leaves it running in simulation: it executes end to end but writes nothing to Amazon or to a store. nodes and edges replace the stored graph wholesale and must be sent together — send one without the other and edges end up pointing at nodes that no longer exist. Send only name, description or variables to change configuration without touching the graph. variables replaces the stored set wholesale and takes the same shape epinium_get_workflow returns — {key, type, value} per entry, type being one of number, boolean, string, select, multiselect, string-list, with options alongside a select or multiselect. Positions are not part of what you send: if the nodes and edges are the same as the saved ones, the saved layout is kept; if they change, Epinium lays the graph out again. Nothing is written if the resulting graph fails validation.
epinium_validate_workflow
ChatGPTRuns the same structural, connectivity and semantic rules that creating or editing a workflow enforces, and saves nothing. name is optional here, unlike in epinium_create_workflow: nothing is saved, so there is nothing to name - you can validate the graph epinium_get_workflow returns without inventing one. Every error comes back with a hint naming the fix. Call it while you are still assembling a graph: a rejected write tells you the same thing, but validating first means you are not guessing which of several changes broke it. Describe the logic and Epinium lays the graph out: position is optional everywhere, and a node only needs parent_node to sit inside a forEach — the container size and the nesting bookkeeping are derived for you. Every {{vars.X}} a node references must appear in variables as {key, type, value}, or it is reported as undeclared; type is one of number, boolean, string, select, multiselect, string-list (a list of strings is string-list, and select/multiselect also need options). A rejected graph comes back with a guidance field: follow it before retrying.
epinium_whoami
ChatGPTDescribes the API key this session is using: its id, whether it belongs to a business account or an agency, the scopes it was granted, and the accounts it can operate on. Call it first when a tool fails with a permissions error, or to find out whether account_id is needed.
