Epinium

Archives 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_adgroup

Changes 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

Changes 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_prompt

Changes 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, `addPrompts` / `removePrompts` link or unlink custom prompts (ids from epinium_list_prompts; unlinking does not delete them), 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) and every prompt added a prompt of the account, 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_cluster

Changes 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_portfolio

Changes 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_target

Changes 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

Changes 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_adgroup

Changes 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_adgroups_batch

Changes 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_batch

THIS 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_targets_batch

What 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_campaign_optimization_history

Runs 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_validate_workflow

Step 2 of 3: validates the rows against each listing's Amazon schema; it saves nothing. In `columns`, mark the identifier with `key: true`, the country with `marketplace: true` and, in vendor, the vendor code with `vendor_code: true`; give each mapped column its `attribute` and leave the rest out. With `file_id`, each `name` is the exact header; each call reads 300 rows from `from_row` and returns `next_row` (null at the end). Without a file, send `rows`, at most 30 per call. Never copy the rows of a file the user uploaded or attached into `rows`: use the upload box or, if it does not appear, `epinium_store_listing_rows` (above about 1,000 rows, suggest claude.ai or Claude Desktop); inline rows only fix a few rows. For data of one product (a real weight), resend only those rows inline with the identifier and that column. Never convert or translate values yourself: Epinium reads decimal commas, `19 x 11 x 8` dimensions and option names; text stays in the file's language. `blocking` and `warnings` come by column and value, with accepted `options`. To fix a value everywhere, add it to that column's `values` and validate again: propose those fixes in one message, never pick an option yourself. `amazon_errors` are problems Amazon already reports. With a country column the report comes per country in `marketplaces`: show it country by country; fix `unrecognized_marketplaces` with that column's `values`. `cascades` make other attributes mandatory (like batteries): show the person each one (product type, attribute = value, `proposal`, `rows`), each country separately, and ask if they confirm it or prefer a task, never by default. `vendor_code_groups` are rows matching several vendor codes: ask per country and combination whether to save the change in all of them, never by default; the rest are left out. Step 3: epinium_apply_listing_update with what the user confirmed in `confirmed_cascades` and `confirmed_multiple`. Nothing reaches Amazon until someone presses Publish.

epinium_validate_listing_update

Copies 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_clone_workflow

Creates 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_prompt

Creates 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. `prompts` are custom prompt ids from epinium_list_prompts that the SEO content of the cluster products will follow. 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_cluster

Creates 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_task

Creates 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_create_workflow

Creates 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_adgroup

Creates 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_campaign

Creates 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_full_campaign

Creates 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_portfolio

Creates 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_targets

Deletes 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: this API cannot unprotect it, so tell them to do it from Segmentation > Clusters instead of retrying. To only take keywords or products out, use epinium_update_cluster instead. Pass `idempotency_key` and reuse it on retries.

epinium_delete_cluster

Deletes 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_delete_workflow

Describes 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.

epinium_whoami

Edits 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_update_workflow

State 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_ad

Enables 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_product_ads_batch

Step 1 of 3 to edit the attributes of many listings from a customer file (then epinium_validate_listing_update and epinium_apply_listing_update). If the user already has a spreadsheet, first call epinium_upload_listing_file, then call this with its `file_id` and `key_column`. If the user describes the change in the chat (even for the whole account) or you generated a CSV or sheet yourself, store the rows with `epinium_store_listing_rows` (listing the identifiers first if needed), never asking for an upload, and use its `file_id` the same way. Put the header of a column with each row's country in `marketplace_column` (then no `marketplace`) and, for vendor, one with the vendor code in `vendor_code_column`. `key_type` says what identifies each row: `sku` (default), `asin` or `ean`; ask if the header does not make it clear. With `ean`, listings whose EAN Epinium lacks come back not found: use SKU or ASIN. NEVER guess the marketplace of a file without a country column: use it only if the user or the file states it, otherwise ASK. You get: identifiers not found in that marketplace and `not_found_elsewhere` (marketplaces where they DO exist: if most of the file is there, ask the user, never switch on your own); `multiple` (an ASIN or EAN with several SKUs: the change goes to all of them, tell the user); the product types, with `schema_status` (`downloading`: call again in a minute); `file` (headers and 3 sample rows); and `candidates`, the attributes those listings can take. With a country column the rest comes per country in `marketplaces`, and unknown countries in `unrecognized_marketplaces`. Map each column to an attribute YOURSELF from the headers and sample rows: never use an attribute outside the list, map internal columns (cost, notes, stock) to nothing, and ask only about ambiguous ones. An attribute with `multiple` (like `bullet_point`) takes one column per entry, each with its `position`. Nothing reaches Amazon until someone presses Publish in Epinium.

epinium_prepare_listing_update

Finds 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_find_data

Ad 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_adgroup

Amazon 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_advertising_product

Amazon 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_seller_product

Amazon 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_amazon_vendor_product

Amazon 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

Keyword 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). `prompts` are the ids of the custom prompts the SEO content generation of its products follows; `expand[]=prompts` returns them whole. Fetches a single cluster by its id. Related records can be inlined with `expand`: products, prompts (nested paths like `connection.country` also work).

epinium_get_cluster

Data 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_connection

Amazon 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_country