add_negative
ChatGPTAdds a negative keyword to a campaign or ad group so its ads stop showing for a search term. An ASIN term becomes a negative product target: at ad-group level on that ad group; at campaign level a Sponsored Products campaign takes it on the campaign itself and a Sponsored Display campaign on each of its ad groups. Match type NEGATIVE_EXACT (default) or NEGATIVE_PHRASE. Level defaults to ad_group, which takes ad_group_id — left out, the campaign's only ad group is used (the answer says so), and a campaign with several is answered with their list; level="campaign" negates the term across the whole campaign. state="ARCHIVED" removes a negative that is already there instead — "remove", "delete", "undo" and "archive" a negative all mean this: the live negative with that text at that level is archived on Amazon (a negative cannot be deleted; archived, it no longer blocks). Removal covers Sponsored Products, Sponsored Display and Sponsored Brands negative keywords (these sit on ad groups only). A Sponsored Brands removal is permanent — Amazon does not let the same negative be added to that campaign again — and is saved as a pending task whatever the mode; a Sponsored Brands negative product target is removed in the Amazon Ads console. When nothing matches at that level, the answer lists where the term is negated. By default the change is saved as a pending task for approval. mode="execute" applies it to Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login; otherwise it is saved as a pending task. To make many changes at once, pass items: a list of up to 1000 changes, each with this tool's own arguments — one call instead of one per change; an argument given beside items (a campaign, a match type, a reason) applies to every item unless the item sets its own. Each item gets the same checks and its own task; with mode="execute" they are applied together, and the answer gives every item's outcome. A long list is taken as far as one call's time allows: continue_from then names the item to send on from, in another call.
add_to_watchlist
ChatGPTAdds campaigns, keywords, targets, search terms or ASINs to one of an account's watchlists in ScaleSKUs — the lists its people follow. The list is named by watchlist_id, or by watchlist_name (an existing list of that name is used, otherwise it is created); an optional section groups the items, and is created when new (a section holds one entity type). An item already on the list is left as it is, and nothing is removed. These are the team's own bookmarks: nothing is sent to Amazon and no ad or bid changes. A watchlist holds up to 300 items and an account up to 20 watchlists.
apply_plan
ChatGPTSaves several changes for one account as pending tasks for approval, in one request; nothing changes on Amazon here. With a plan_ref (plans expire after 7 days) it takes item numbers or all=true; without one, it takes up to 1,000 items in actions, each naming one of the change tools listed in its schema with that tool's own arguments, as declared there. Supported changes: negatives, keyword harvests, new keywords, and the bid, budget, state, placement and other edits of campaigns, ad groups, keywords, targets and product ads. Each item passes the same checks as the same change made with its own tool; nothing changes on Amazon until the tasks are approved and executed. Items already saved from this plan, or matching a change already pending for the same entity, are skipped with the existing task's handle. Returns the new task handles, plus skipped and failed items with reasons.
check_negation_status
ChatGPTReports whether search terms are already negated in a Sponsored Products account, checking both campaign-level and ad-group-level negatives. Match type is respected: an exact negative blocks a term with the same words; a phrase negative blocks any term containing its words in order as whole words ("cat" blocks "cat food", not "catalog"). Only ENABLED negatives count unless include_inactive=true. Returns, per term, campaign_negated and ad_group_negated flags plus the matching negatives (level, keyword_text, match_type, state, campaign_id, ad_group_id, matched_by). Checks up to 50 terms per call, optionally within one campaign and/or ad group. Answers questions like "is this term negated, and at which level?". Sponsored Brands, Sponsored Display and product-target negatives are not covered.
create_ad_group
ChatGPTCreates an ad group with a name and default bid in an existing SP, SB or SD campaign, identified by its handle or its exact name. default_bid is required (Amazon rejects an ad group without one) and is checked against the platform's per-bid safety cap. The new ad group starts empty: it serves only after ads and, where the campaign needs them, keywords or targets are added. By default the change is saved as a pending task for approval. mode="execute" creates it on Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login (otherwise it is saved as a pending task) and returns the new ad group's handle as ad_group_id.
create_automation_rule
ChatGPTCreates an automation rule: conditions (combined with AND unless a condition says logical_operator OR) and one action. A rule acts on numbers (spend, ACoS, budget use …) at the times it is scheduled; it has no hour-of-day condition — to raise or cut bids or budgets by hour of day (day-parting), use the day-parting schedule tool instead. Where the account's changes_allowed is "automation" the rule is created switched on (status created_live) and runs from its next check; where it is "approval" it is created as a disabled draft; "manual" and "read_only" accounts refuse it (automation_off_for_account). A draft changes nothing on the account until it is enabled. Action value: "20" means 20% for a percentage action; set_bid / set_budget take an amount in the account's currency; negate_search_term takes NEGATIVE_EXACT or NEGATIVE_PHRASE. Budget increases are capped by max_multiplier (N× the campaign's base budget; raised budgets reset to base daily by default) or max_value (base plus that amount); for bids, min_value and max_value are absolute limits. A budget increase may also carry max_multiplier_boost, a higher ceiling reached only while the campaign is profitable today, and an account_gate, which lets the rule raise budgets only while the whole account's TACoS over its last days is under a limit. A rule identical to an existing one returns status noop with that rule's handle. If another active automation already performs the same operation (bid down, budget up …) on some of these campaigns, the result is status needs_ack listing it, and nothing is created unless acknowledge_overlap=true; where both fire, the rule with the lower priority number acts. Once enabled, policy decides what runs unattended: by default changes scored at confidence 80 or more run within its caps and the rest wait for approval on the ScaleSKUs Tasks page; policy.execution="approval" holds every change for approval.
create_campaign
ChatGPTCreates a campaign. For Sponsored Products (default) and Sponsored Display it builds the whole campaign as one task: campaign, ad group, product ad(s) and targets, plus bidding strategy and top-of-search placement for SP. If a required piece is missing, the result is status needs_input listing it and nothing is saved. The SP build requires advertised_asins or advertised_skus, ad_group_default_bid and, for a MANUAL campaign, at least one keyword or product target; the SD build requires advertised_asins, headline and ad_group_default_bid (views remarketing, tactic T00030, needs no targets). Bids are the user's: with no ad_group_default_bid the result is needs_input with Amazon's suggested bids (suggested_bids) — ask the user what bids they want and call again with them, or with use_suggested_bids=true when the user says to use Amazon's. A bid given (ad_group_default_bid, keyword_bids) is used as given. Campaign shells (a campaign with no ad group, ads or targets) are never created: do the analysis first — the product to advertise, its keywords or product targets, and the bid. Sponsored Brands is not supported here because it cannot be built whole without a brand creative. A seller ad account's products are advertised by SKU and a vendor ad account's by ASIN: a product given the other way is converted when it can be (product_notes says which), otherwise left out, and with no product left nothing is saved. Keywords without keyword_bids take ad_group_default_bid (Amazon's suggestion only with use_suggested_bids=true); a default above Amazon's suggestions is kept and noted in bid_notes; a bid with no market price above the account's ceiling returns needs_input unless confirm_high_bid=true. By default it is saved as a pending task for approval. mode="execute" creates it on Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login (otherwise it is saved as a pending task) and returns the new campaign's handle as campaign_id.
create_dayparting_schedule
ChatGPTCreates a day-parting schedule — bids, budgets or campaign status changed by hour of day and day of week (time-of-day / dayparting), on its own every hour. Where the account's changes_allowed is "automation" it is created enabled and starts at the next window boundary (status created_live); where it is "approval" it is created paused and changes nothing until it is enabled; "manual" and "read_only" accounts refuse it (automation_off_for_account). mechanism: bid (default; raises or cuts bids by each window's change_pct — SP keywords and targets, SB keywords, SD targets), budget (campaign budgets: a negative window cuts them in its hours; a positive window raises a budget by up to its change_pct only while that campaign is on course to run out before the window ends), state (campaigns paused inside the windows, restored outside; a window needs no change_pct), or a placement — place_top (top of search), place_pages (product pages), place_rest (rest of search): the placement's bid adjustment on Sponsored Products campaigns is set to each window's change_pct, 0–900, inside it and goes back to the campaign's own adjustment outside. ad_products: which ads it acts on — all three ["SP","SB","SD"] (default), or any of them; ask the user. Campaigns Amazon manages are left out of every schedule (Amazon refuses outside changes); amazon_managed in the answer carries the note and their names. Sponsored Brands bids are changed on keywords only, and not in a campaign where Amazon sets the bids (automated bidding); placements are SP only. scope: {mode: account | portfolio | campaign | campaign_except | portfolio_except, ids} — a schedule acts only on what serves (an enabled keyword or target in an enabled ad group of an enabled campaign), whatever the scope. Without windows, they come from the account's hour-of-day conversion analysis, each with its evidence; the result is status pending while that analysis is not ready (it computes overnight) and noop when it finds no window (too little hourly data, or no hour stands out). Window hours are in the marketplace's local time; an hour belongs to one window only. Analysis windows are for bid and budget schedules (a state schedule takes only the hours that convert worst); a placement schedule needs its windows given. An identical existing schedule returns noop with its handle. When other schedules or automation rules already act on these campaigns, the result is status needs_ack listing them, and nothing is created unless acknowledge_conflicts=true. Once enabled, the schedule keeps each entity's base value and restores it when a window ends; guards bound every change — a window asking more than cap_pct moves cap_pct, and the result says so in notes. With schedule_id (the dps_… handle of an existing schedule) it changes that schedule and creates nothing: each of name, scope, windows (the complete list) and guards that is given replaces what the schedule has, what is omitted is kept, and the mechanism stays (status updated; noop when nothing differs). An enabled schedule carries on under the new set-up within about 5 minutes, so changing one requires user_confirmed=true, otherwise the result is needs_ack and nothing changes.
create_keyword
ChatGPTAdds a keyword with a match type (EXACT default, PHRASE or BROAD) and a bid to an ad group of a manual Sponsored Products campaign, or — with ad_product SB and a bid — to a keyword ad group of a Sponsored Brands campaign. Takes the campaign (handle or exact name) and the ad group (handle, or exact name within that campaign). A bid given is used as given, checked against the platform's per-bid safety cap. With no bid, nothing is queued: the result is needs_bid with Amazon's suggested bid for it there (suggested_bid) — ask the user what bid they want and call again with bid, or with use_suggested_bid=true when the user says to use Amazon's suggestion. If the same keyword and match type already exist in the ad group, the result is status skipped with the existing keyword's handle and nothing is saved. By default the change is saved as a pending task for approval. mode="execute" creates it on Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login (otherwise it is saved as a pending task) and returns the new keyword's handle as keyword_id. To make many changes at once, pass items: a list of up to 1000 changes, each with this tool's own arguments — one call instead of one per change; an argument given beside items (a campaign, a match type, a reason) applies to every item unless the item sets its own. Each item gets the same checks and its own task; with mode="execute" they are applied together, and the answer gives every item's outcome. A long list is taken as far as one call's time allows: continue_from then names the item to send on from, in another call.
create_listing
ChatGPTCreates a new Amazon listing for a seller, through the account's Seller Central connection: an offer on a product already on Amazon (offer_only=true with its asin) or a new product. sku is a SKU the seller does not use yet; product_type, attributes and the copy are Amazon's, with price, mrp, hsn, quantity, condition and images (Amazon.in needs mrp and hsn). mode="check" (default) has Amazon validate the new listing; nothing is created. mode="task" does the same and saves it as a pending task for approval in ScaleSKUs; it is created on Amazon only where listing creation is switched on for the account. Vendor Central listings are not covered.
create_portfolio
ChatGPTCreates a portfolio — a group of campaigns with an optional budget cap above their own budgets. budget_policy NO_CAP (default) sets no cap; DATE_RANGE caps spend at budget_amount between start_date and end_date; MONTHLY_RECURRING caps it at budget_amount each month. A name already used by a portfolio of the account is refused. By default it is saved as a pending task for approval. mode="execute" creates it on Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login; otherwise it is saved as a pending task.
create_product_ad
ChatGPTAdds a product ad to an ad group in SP (default) or SD, advertising a SKU (seller ad accounts) or an ASIN (vendor ad accounts); a product given the other way is converted when it can be (product_note says which), otherwise the result is status error and nothing is saved. Takes the campaign (handle or exact name) and the ad group (handle, or exact name within that campaign). An ad group with no product ad serves nothing. For SP, if the SKU or ASIN is already advertised in the ad group, the result is status skipped with the existing ad's handle and nothing is saved. By default the change is saved as a pending task for approval. mode="execute" creates it on Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login (otherwise it is saved as a pending task) and returns the new ad's handle as ad_id. To make many changes at once, pass items: a list of up to 1000 changes, each with this tool's own arguments — one call instead of one per change; an argument given beside items (a campaign, a match type, a reason) applies to every item unless the item sets its own. Each item gets the same checks and its own task; with mode="execute" they are applied together, and the answer gives every item's outcome. A long list is taken as far as one call's time allows: continue_from then names the item to send on from, in another call.
create_strategy
ChatGPTCreates a strategy: 1 to 12 automation rules for one scope, saved together, or none at all. Where the account's changes_allowed is "automation" its rules are created switched on (status created_live); where it is "approval" they are disabled drafts; "manual" and "read_only" accounts refuse it (automation_off_for_account). Each rule is either a full rule draft (rule_name, entity_type, conditions, action …) or {recipe: <automation-library recipe key>, …overrides}, with the recipe's thresholds set from this scope's last 30 days (and target_acos when given). Each rule is named "<strategy name> — <rule name>"; the strategy's scope applies to rules without their own, and its policy to every rule, with a rule's own policy keys taking precedence. All rules are checked before anything is written: an invalid rule stops the whole strategy; an overlap, with another active automation or between two of its own rules doing the same operation (bid down, budget up …) on the same scope, returns status needs_ack and nothing is created unless acknowledge_overlap=true; a rule identical to an existing one is skipped and listed with its handle. Drafts change nothing until each is enabled. The response includes the review routine for the new rules (review cadence and next due date).
create_table_view
ChatGPTSaves a named view of one of ScaleSKUs' tables for the signed-in user — it appears under "My views" in that table's Views panel and opens with one click on any account. A view keeps the table's settings (built-in view, ad product, tier, tab…), search, sort and metric filters such as "ACoS above 40 and spend above 500"; never dates — it opens on the dates in view. Each table keeps its own settings (the table views list names them by key); a setting a table does not keep is refused with the ones it does. With share_with_team=true everyone in the workspace sees it under Team views; otherwise it is the user's own. Nothing is sent to Amazon.
create_target
ChatGPTAdds a product target (an ASIN) with a bid to an ad group: an ad group of a manual SP campaign (default) or an SD ad group. Takes the campaign (handle or exact name) and the ad group (handle, or exact name within that campaign). A bid given is used as given, checked against the platform's per-bid safety cap. With no bid, nothing is queued: the result is needs_bid with Amazon's suggested bid for it there (suggested_bid) — ask the user what bid they want and call again with bid, or with use_suggested_bid=true when the user says to use Amazon's suggestion. If the ASIN is already a product target in the ad group, the result is status skipped with the existing target's handle and nothing is saved. By default the change is saved as a pending task for approval. mode="execute" creates it on Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login (otherwise it is saved as a pending task) and returns the new target's handle as target_id. To make many changes at once, pass items: a list of up to 1000 changes, each with this tool's own arguments — one call instead of one per change; an argument given beside items (a campaign, a match type, a reason) applies to every item unless the item sets its own. Each item gets the same checks and its own task; with mode="execute" they are applied together, and the answer gives every item's outcome. A long list is taken as far as one call's time allows: continue_from then names the item to send on from, in another call.
create_task
ChatGPTCreates a manual to-do in the account's task list in ScaleSKUs, the list its team works from (/account/{profile}/tasks), for requests such as "add this as a task", "make a task for my account manager" or "remind the team to do X". It is a human-workflow task (advisory, status pending) on the given profile, tagged as filed from chat by the requester; details holds the full request and any table or data summary, so whoever picks it up has the context. The task is a record inside ScaleSKUs: nothing is sent to Amazon. The same title and details filed again are counted on the existing task. Returns the task id.
delete_sheet_report
ChatGPTDeletes an automated Google Sheet report by report_id: its schedule is removed and it no longer runs. This cannot be undone, so it requires user_confirmed=true: without it the result is status needs_ack and nothing is removed. The sheet and the rows already written stay in the user's Google Drive.
delete_table_view
ChatGPTDeletes a saved view of a ScaleSKUs table, by its view_id: one of the user's own, or one they shared with their team (it then goes for everyone; only its maker may). Only the saved view goes: the table and its data do not change, and nothing is sent to Amazon. This cannot be undone, so it requires user_confirmed=true: without it the result is status needs_ack naming the view, and nothing is deleted.
delete_watchlist
ChatGPTDeletes one of an account's watchlists in ScaleSKUs, with its sections and every item on it, for everyone on the account. This cannot be undone, so it requires user_confirmed=true: without it the result is status needs_ack, naming the list and how many items it holds, and nothing is deleted. Only the bookmarks go: the campaigns, keywords, targets, search terms and products themselves are untouched and nothing is sent to Amazon.
describe_table
ChatGPTReturns one analytics table's columns (name, type, nullable, key) and a few sample rows. Covers only the Amazon-data tables open to analysis (ads reports, master entities, stream, SP-API retail, Brand Analytics, catalog); any other table returns an error. For a table with a profile_id column, sample rows come only from the account given as profile_id, and without one only the schema is returned. Sample rows from sensitive tables are withheld, sensitive-looking column values are redacted, and id columns come back as opaque handles.
describe_tools
ChatGPTWhat each ScaleSKUs tool can do, in full. With no tool: every tool this login can call — what it does, whether it reads or changes something, its views and how many combinations of its choices it has. With tool=<name>: that tool in detail — every argument with its type, whether it is required, its allowed values and default; each view and the arguments it takes; for a tool that changes Amazon, which change it makes for Sponsored Products, Brands and Display and which of those Amazon does not take; how a change is applied (task for approval or at once); and every combination of its choices. Use it to answer "what can this tool do", to pick the right tool and arguments before a call, or to explain why a combination is refused. Reads nothing from an account.
edit_sheet_report
ChatGPTChanges the settings of an automated Google Sheet report by report_id: its status, sql, title, mode or schedule. Only the settings given are changed. status "paused" stops its runs and leaves the sheet as it is; status "active" restarts them from the next scheduled time, and also clears a stop after failures or a Google reconnect. A new sql is checked and run once before it is saved: a check of level "error" stops it with status needs_fix unless acknowledge_checks=true, and a query that fails leaves the report as it was. A changed sql or mode rewrites the report's tab once in the new shape. format changes how the tab looks — column formats, header colours, frozen panes, banding, a filter, widths, colour rules, header notes — and is applied to the tab as it stands.
execute_tasks
ChatGPTApplies pending change tasks (by tsk_… id) to the user's Amazon Ads account through ScaleSKUs' audited pipeline: bids, budgets, negatives, new campaigns and other queued changes go live on Amazon. It makes no change of its own choosing and takes no change arguments: each task was created earlier — with one of the change tools (each declared with its own arguments), by the user in ScaleSKUs or by an automation rule — and is applied exactly as it was saved and shown. Requires two-factor on the user's login; the per-account daily cap on applied changes applies; only tasks on accounts the user can access run. Returns each task's outcome and action-log id.
export_to_sheet
ChatGPTPuts a result into a new Google Sheet in the user's own Google Drive, once, and returns the sheet's link. Two ways to fill it: sql — a read-only SQL SELECT against ScaleSKUs' analytics database (MySQL 8) whose full result is written, up to 50,000 rows (for large lists such as every wasted search term or every product's 90-day performance); or rows — a table already in the conversation (an analysis result, a comparison, a plan), one object per row keyed by column name, up to 5,000 rows, written as given (columns sets the column order). The rows are not in the response: it returns the status, row count, column names, title and URL. Each call creates a new sheet; it is not refreshed afterwards. The sql form accepts one SELECT or WITH statement over Amazon-data tables only, rows limited to the accounts the user may read, 30-second query limit, and is checked for mistakes that make numbers wrong (no account filter, inventory summed across snapshots, wrong attribution column …): a check of level "error" stops the export (status needs_fix) unless acknowledge_checks=true; warnings are returned with the link. Needs the user's Google account connected once; when it is not, the status is needs_google_connection with a connect_url. Returns an error when sheet export is not enabled. The workbook can hold several tabs (tabs), each from its own sql or its own rows, and each tab can be laid out with format: number, currency, percent and date formats per column, header colours, frozen rows and columns, banded rows, a filter, column widths, colour rules, a totals row, charts and header notes. Left unformatted, a tab still gets a styled header, banding, a filter, fitted columns and formats read from its values. destination="excel" puts it in a new Excel workbook (.xlsx) in the user's own OneDrive instead, with the same tabs and column formats, header style, frozen rows, filter and totals row (colour rules, charts and notes are left out there); it needs the user's Microsoft account connected once, and when it is not the status is needs_microsoft_connection with a connect_url.
find_entity
ChatGPTResolves a campaign, ad group, keyword, target or product ad to its opaque handle from the master (current-state) tables, including paused, zero-impression and no-report entities that performance reports omit. Three ways in: (1) a name — exact by default, or match="contains" for part of one; (2) an opaque handle to confirm; (3) no name plus a parent, which lists what is inside it (the ad groups of a campaign, the keywords/targets/product ads of a campaign or ad group). Parents (campaign, ad_group) take a handle or the exact name. Several hits come back as a matches list with name, status and parent, enabled first; none is picked. An exact name that matches nothing but is part of other names returns those as a matches list marked exact_match=false. A product ad is found by its ASIN or SKU. Without entity_type, a name is looked up exactly across every kind. Also finds campaigns and ad groups created through ScaleSKUs in the last 72 hours that the hourly sync has not pulled in yet (source "recent_create"), SP auto-targeting groups by name (close-match, loose-match, substitutes, complements), product targets by bare ASIN, Sponsored Brands targets from the targeting report (source "targeting_report"; Amazon offers no list of them), and campaign or ad group names that differ only in punctuation or spacing (flagged in match_note). A keyword handle asked for as a target (or the reverse) is answered with the entity and a hint. Each result carries last_seen_at and is_stale; a Sponsored Display target also carries target_kind (product, category, similar_product, views_remarketing, purchases_remarketing, audience, or unknown), lookback_days and target_label. When nothing matches, the answer holds suggestions: close names, what the parent holds, or the same text found under the other type (keyword vs target).
get_adgroup_performance
ChatGPTReturns ad-group performance across SP, SB and SD: impressions, clicks, spend, sales, orders, ACoS, ROAS, CTR, CPC and CVR, with status, default bid and parent campaign, for ad groups with impressions in the window. Amazon's SB and SD reports carry no ad-group id, so each SB or SD campaign is one row. On acos/roas/ctr/cvr sorts and any ascending sort, rows under the noise floor (min_clicks, default 10; optional min_spend) rank after rows that meet it. ACoS is null (not 0) for rows with spend and no sales, and those rows rank after rows with sales on ACoS sorts. Sales and orders come from Amazon's ad-group reports, capped at the parent campaign's campaign-report figure (capped rows carry sales_reconciled=true and campaign_sales); the grains differ, so ad-group sales may not sum to campaign totals, as the reconciliation field explains. A window that includes today blends provisional same-day Marketing Stream data.
get_asin_competitors
ChatGPTFor your advertised ASINs, returns the top competitor ASINs (rivals most clicked on the same top search terms), with shared_terms and each rival's click & conversion share vs yours — from the weekly Amazon Search Terms report. Use to answer: who competes with this ASIN, where rivals out-click or out-convert us, and which competitors to target in ads. A high comp_avg_conv_share vs our_avg_conv_share means the rival converts that demand better than we do. Pass an asin to focus one product. Each product and competitor carries its Amazon price as read today (Buy Box, "was" price, a running deal, offers, best seller rank, the change on a week before) and gap_pct = the competitor's price against ours (negative = it sells for less). Prices are read once a day; a product with no reading in 3 days has price null. With asin and keyword_gap=true, also returns the searches its competitors are among the three most clicked on and it is not, with searches a month and whether the account bids on each.
get_asin_traffic
ChatGPTGet per-ASIN retail traffic and conversion from Amazon Sales & Traffic: sessions, page views, buy-box %, unit-session % (conversion rate), units ordered and total ordered-product sales. This is the listing/retail health of each product (all channels, not just ads). Low conversion or low buy-box here explains why ads underperform.
get_audit_scores
ChatGPTThe audit of one account. One tool, several views (view): scores — a live overall score with sub-scores (waste control, product readiness, budget efficiency, structure) and the top findings; findings — the prioritised fix-list, each finding ranked by the money at stake; report — a published audit report (the level-by-level Owner Report) with the logic behind each number. Each view takes the filters marked with its name; the default is scores.
get_automation_action_logs
ChatGPTGet automation action logs — the history of all automated changes made to campaigns, bids, budgets, and keywords. Shows what changed (entity name, not just id), when, the old and new values, who or what triggered it (rule, platform user, or system), and whether the action succeeded or failed — with the error class and error message for failed actions. Action types cover budget changes (budget_update, set_budget, increase_budget_pct, decrease_budget_pct), bid changes (bid_update, set_bid, increase_bid_pct, decrease_bid_pct), status changes (status_change, pause, enable), and negative keywords (neg_keyword). Filter by action type, status, or date range.
get_automation_performance
ChatGPTReturns how an automation rule has done over the last N days (default 14, at most 90), worked out the same way on every call: activity (changes proposed, run on their own, run by a person, waiting for approval and why, closed, rejected, failed; direct writes and why it skipped), outcomes (its newest 40 changes that are at least 3 full days old, read against the days before: worked %, ACoS / spend / sales a day before vs after; read and too_soon_or_no_data show how many changes the figures rest on, and worked_pct is null when none could be read yet), confidence (the 0–100 scores its changes carried and how often each band worked), state (active, last run, what it found, matches today, overlaps with other automations), its policy, and its review routine (cadence, next due date, owner, last verdict and notes, and whether it is in approval mode because a review is overdue).
get_automation_rules
ChatGPTGet automation rules configured for a profile: bid rules, budget rules, status change rules, negative keyword rules. Shows conditions, actions (with caps), schedule, scope, approval / execution mode, where each came from (dashboard, MCP + which assistant, a strategy), last run — and ownership: does (the operations it performs: bid ↑, bid ↓, budget ↑ …), rank among the active rules (lower acts first) and overlaps (other active rules doing the same operation on the same campaigns, and which one acts where both fire). Read this before creating or changing a rule. Filter by active/inactive or action type.
get_briefing
ChatGPTReturns a briefing on one account in one call: the headline, the trajectory (what changed), what is budget-capped right now, and the weakest audit areas, as a labelled bundle. For requests like "brief me", "what's up" or "where do I stand". Read-only.
get_budget_analysis
ChatGPTCampaign budgets of one account. One tool, several views (view): efficiency — how each campaign used its budget over a date range, from the daily campaign reports; amazon_recommended — the campaigns Amazon recommends a higher budget for, with its estimate of missed impressions, clicks and sales; live — pacing right now: each campaign's budget, the share of it used today and the estimated spend. Each view takes the filters marked with its name; the default is efficiency.
get_campaign_performance
ChatGPTReturns campaign-level performance (impressions, clicks, spend, sales, orders, ACoS, ROAS, CTR, CVR) for one ad product per call: Sponsored Products (default), Sponsored Brands or Sponsored Display. Filterable by campaign status and minimum spend; sorted by the chosen metric. When the window includes today, today's figures come from the live Marketing Stream and are provisional. Only campaigns with delivery in the window are listed; the coverage block counts the account's other campaigns (paused, archived or dormant) that had none. totals sum the returned page; full_totals cover every matching campaign regardless of paging. When ad_product is not given, other_products reports Sponsored Brands and Sponsored Display spend and sales for the same window. ACoS is null (not 0) for campaigns with spend and no sales, and those sort after the rest on an ACoS sort.
get_campaign_structure
ChatGPTReturns per-campaign structure analysis: budget utilization, ad group, keyword, target and negative counts, a structure_score (0-100) with the issues found, and product_mix. Metrics come from the daily campaign reports, with today (provisional) from the live Marketing Stream when the window includes it; counts come from the configured entities and are null, not 0, when the account's entity data has not synced yet. Issues cover missing or too many ad groups, few or no keywords/targets, no negatives with active spend, a budget likely capped (above 95% utilization) or underused (below 20%), and 50+ clicks with no sales. product_mix shows what a campaign advertises by sub-category: specific (one), mixed (several; reasons name the products outside the main one) or unknown. A rule scoped by sub-category acts only on specific campaigns unless its scope also includes generic (mixed) ones. Covers one ad product per call (SP default, SB or SD); only campaigns with report rows in the window are listed.
get_change_task
ChatGPTReturns one change task (a proposed, queued or executed change to an Amazon Ads entity) by its opaque handle (tsk_…). Covers its status (pending, approved, executed, …), lifecycle (planned → queued → attempted → applied or failed; applied means the Amazon change succeeded), task type, ad product, the target entity with its campaign and ad group, origin, proposed action, expected impact, metrics, reason and confidence, the linked action-log id, any resolution (e.g. already_in_effect, stale, superseded), the checks recorded when it was proposed (e.g. "bid already reduced 20% 5 days ago by rule X"), and its history: recent changes to the same entity or term, day-parting flips, the latest change's result, related tasks and a change-log link. Also returns attempt count, last error, who created, approved and executed it (null for system, automation or outside work) and timestamps. Covers machine change tasks, not team to-do tasks. A task on an account the caller cannot access returns an authorization error.
get_commitments
ChatGPTList the commitments (measurable targets) set for an account and progress toward each: target metric/operator/value, baseline, current value, % to target, status (on_track/at_risk/behind/achieved/expired/withdrawn), deadline and days remaining. Agency-internal.
get_daily_trends
ChatGPTDay-by-day figures of one account over a date range. One tool, several views (view): ads — advertising only: spend, sales, ACoS, impressions, clicks and orders a day, for one ad product or one campaign; business — the whole business a day: total, ad and organic sales, ad spend, TACoS, sessions and units. Each view takes the filters marked with its name; the default is ads.
get_dayparting
ChatGPTReturns an account's day-parting: its schedules (id, name, ENABLED / PAUSED, mechanism bid | budget | state, scope, windows as hours of the week with their bid / budget change %, conflicts with other automations, source, last run, review date) and the windows its hour-of-day analysis supports over the last ~9 weeks, each with the change %, confidence and evidence (conversion rate in those hours vs the account baseline). Hours with fewer than 30 clicks in that span are not read. A new schedule on the same campaigns and mechanism as an existing one duplicates or conflicts with it. On a new account the analysis can still be pending; it is computed overnight. amazon_managed: the campaigns Amazon manages, which every schedule leaves out because Amazon refuses outside changes to them, with the note that explains it to the user.
get_due_reviews
ChatGPTLists the automation rules due or overdue for review, plus those falling due within the next N days: account, rule id and name, whether it is active, due date, days overdue, owner, review cadence, last verdict and review date, and whether it is in approval mode for want of a review. Without profile_id it covers every account the user can see. An automation whose review is more than 7 days overdue stops acting on its own (approval mode) until it is reviewed.
get_duplicate_targeting
ChatGPTFind self-competition: keywords or product targets that run in multiple campaigns at once, so your own campaigns bid against each other and inflate CPC. Returns each duplicated entity with the campaigns it appears in, combined spend/sales, estimated wasted spend, and which instances to keep vs pause. Sponsored Products only.
get_entity_tiers
ChatGPTGet the performance tiers for products or targets, computed LIVE from the daily fact tables (sales contribution over the 90 days through yesterday — today is still arriving and is left out, as date_range and window_note show). ASINs are classed Super Hero / Hero / Challenger / New Launch and targets Champion / Contender / Watchlist / Testing. Returns the tier distribution plus the entities in each tier — the quickest read on which products/targets drive the account and which are still proving out.
get_inventory
ChatGPTGet FBA inventory levels per SKU (latest snapshot): sellable units (fulfillable + FC transfer — units moving between fulfilment centres, e.g. after an IXD/cross-dock inbound, are still for sale), the reserved split (fc_transfer / fc_processing / customer_orders), inbound pipeline, unsellable, plus sales velocity (avg daily units, 30d), days_of_cover on sellable stock, and a stockout_risk flag (out_of_stock / critical / low / ok). Sort by days_of_cover for soonest stockouts, or out_of_stock_only for advertised-but-unbuyable products. Answers "what runs out first / when / should I throttle ads / how much should I reorder?".
get_keyword_competition
ChatGPTReturns, per search term, a blend of four sources: market demand, the brand's impression and purchase share and the market median price (latest Search Query Performance week); the account's Sponsored Products spend, sales, ACoS and CVR from the search-term report over the last N days through yesterday (today is still arriving and is left out); the top 3 clicked competitor ASINs with their click and conversion share (latest Amazon Search Terms report period, plus brand, list price and BSR where cached); and Amazon's suggested bid. Each row has an opportunity label, first match applying: press_rival_not_converting (a rival takes 10%+ of clicks but 2% or less of conversions), fix_losing_important_term (demand 500+, purchase share under 5%, ACoS over 40%), defend (purchase share 20%+ and ACoS not above 40%), grow_share (demand 500+, purchase share under 15%) or monitor. Covers the given keyword (substring match), or without one the account's top-spend search terms that appear in the Amazon Search Terms report.
get_keyword_performance
ChatGPTKeywords of one account. One tool, several views (view): performance — per-keyword impressions, clicks, spend, sales, orders, ACoS, ROAS, CTR, CPC and CVR (Sponsored Products and Brands); efficiency — the same keywords labelled by efficiency, each with a suggested bid. Each view takes the filters marked with its name; the default is performance.
get_listing
ChatGPTReads a seller's Amazon listing, one SKU at a time, through the account's Seller Central connection; nothing changes. view="analyze" (default) returns the copy on Amazon now with a check against Amazon's listing rules, the attributes filled and empty, the product's sales, sessions, conversion and Buy Box share (30 days against the 30 before), its rating, the searches shoppers bought it from (Search Query Performance and its ads' search terms) with whether the copy holds their words, and candidate search-term words. view="attributes" lists every attribute this product type can take, with its value now, limits and allowed values (names= for the full description of some). For a product not yet listed: view="find_product" looks a product up on Amazon by barcode (identifier) or words (keywords) and says whether the seller sells each ASIN already; view="product_types" gives Amazon's product types (item_name or keywords); view="requirements" lists what Amazon requires (product_type; offer_only=true for an offer on an existing ASIN). Vendor Central listings are not covered.
get_market_basket
ChatGPTGet Market Basket Analysis (Amazon Brand Analytics, MONTHLY): the ASINs most often purchased together with your product in the same order, with the combination rate. For cross-sell / bundle opportunities and complementary product targeting (ASIN targets): "what else do buyers of this ASIN also buy?". Returns the LATEST month by default; pass date_from/date_to (YYYY-MM-DD) for a past month or range (see available_range). Brand-Registry gated; data lags ~1 month.
get_mis_overview
ChatGPTGet a management-information overview across the accounts you manage: per-account counts of bid/budget/status/negative/creation changes and how many were automation vs platform vs external, plus an average change-validity score — over a date window. Answers "what has actually been happening across the book?" Agency-internal.
get_next_actions
ChatGPTReturns the value-ranked queue of next actions for one account: the top money moves (growth-audit findings, wasted spend to cut, search terms to harvest, budget-capped winners) in one prioritised list, for questions like "what should I do", "where do I start" or "give me the priorities". Each action names the entity, the number behind it, the expected result and the change it maps to in the task pipeline. Read-only.
get_optimization_history
ChatGPTWhat was changed on an account, and what it did. One tool, several views (view): optimizations — the changes made through ScaleSKUs, each once, with its source and result; changes — Amazon's own change history for one account: every change made anywhere, by entity and change type; stories — the changes grouped into recognisable patterns (scaled winner, cut waster, bid swings) with their impact; team — recent changes across every account the user can access — what the team worked on (no profile_id needed). Each view takes the filters marked with its name; the default is optimizations.
get_orders_by_place
ChatGPTWhere one account's orders were delivered: units, orders and sales by state, city, pincode area or product, for a date range (up to the last 200 days). Use it for "which cities buy this product", "where are we not selling", or to compare places before a regional offer. Each row also splits what came back of those orders: RTO (undelivered / refused) and customer returns, with rto_rate_pct — "where is RTO high". Narrow it with asin, state or city. Figures are the account's own orders on Amazon in its own day; units shipped from Amazon stock for other channels are given apart (other_channel_units) and are not sales. An order is counted once: add orders up by place or day, never by product.
get_placement_performance
ChatGPTGet campaign-level placement performance for Sponsored Products: how spend, sales and orders split across Top-of-Search (TOS), Rest-of-Search (ROS) and Product-Pages (PDP). Answers "where are my ads showing and which placement converts best?" Includes per-placement share %, spend and cost per acquisition, the inputs for placement bid adjustments. Paginated: 20 campaigns per page by default (max 200), with offset/limit and total_count/has_more.
get_portfolios
ChatGPTLists an account's advertising portfolios: portfolio_id (an opaque pfl_ handle), name, state, budget amount and budget policy. Returns enabled portfolios by default; the state filter selects paused, archived or all. Each portfolio appears once, even when the account is synced through more than one connection.
get_product_health
ChatGPTGet product-health alerts: advertised ASINs that are out-of-stock, unbuyable, suppressed, or have lost the buy box — while ads keep spending on them. Surfaces "spending while broken" waste with the affected spend/sales and how many campaigns are still running. The single fastest place to stop silent budget leakage. Each alert includes a per-sku stock breakdown (skus / skus_in_stock / skus_total) — an ASIN is flagged OOS only when EVERY sku is out; if skus_in_stock>0 the ASIN still sells via another sku. Covers the last 7 days.
get_product_performance
ChatGPTReturns advertising performance per ASIN: impressions, clicks, spend, sales, orders, units, ACoS, ROAS, CTR, CVR, ad type and listing status. Covers Sponsored Products and Sponsored Display advertised products; Sponsored Brands has no ASIN-level report, so these totals exclude SB spend and sales. When the window includes today, today's figures come from the live Marketing Stream. Answers questions like "which products are profitable to advertise and which spend without selling?". Where the account has Seller Central data it also returns, by default, the business report per ASIN — total sales (all orders, ads and organic), units ordered, sessions, page views, average Buy Box % and organic sales (total less ad sales, an estimate); include_business_report=false leaves it out. Funnel fields are null (not 0) when an ASIN has no business-report row or its row has no synced sessions or page views, and has_data is true only when real sessions or page views are present. Sorting by acos, roas or ascending drops ASINs under min_clicks (default 10). ACoS is null (not 0) for ASINs with spend and no sales, and those sort after the rest on an ACoS sort.
get_product_ratings
ChatGPTStar ratings of one account's products as Amazon reports them: the rating now, how many ratings it rests on, and the reviews and low-rating reviews received in the newest month on record. Use it for "which products are rated under 4", "did reviews drop", or before putting ad spend on a product. Pass asin for one product and its rating over time. Seller accounts only. A product that is not in the answer has no rating on record: say unknown, never "no reviews".
get_product_taxonomy
ChatGPTReturns the account's products grouped by department › category › sub-category, with how many products and how many are advertised (an ENABLED Sponsored Products ad) in each. Placement comes from Amazon's browse path; otherwise from the same leaf category elsewhere in the catalog, a variation sibling, the products it is advertised with, or an AI classification of the title. A person's override takes precedence over all of these. The sub_category and category names are the exact values that product-scoped automation rules and strategies match on. With asins, returns where each given product sits and how that is known (source, confidence, basis). "unknown" counts products no source could place.
get_profile_summary
ChatGPTReturns a high-level summary of an Amazon Ads account for a date range (default: the last 14 days through today): ad totals across SP, SB and SD (impressions, clicks, spend, sales, orders, ACoS, ROAS, CTR, CVR) with a breakdown by ad product (products with spend only); SP campaign counts by status; a blended store view (total sales from Amazon Sales & Traffic, ad sales, ad spend, organic sales and share, total orders, ACoS, TACoS); the settled-attribution date (the freshest ~2 days are provisional); and a coverage summary of report-active vs all campaigns per ad product. SP sales use 7-day attribution for sellers and 14-day for vendors. totals.sales is settled ads-report sales; blended.ad_sales comes from Marketing Stream, includes late-attributed conversions and runs about 3% higher. In totals and by_ad_product, ACoS reads 0 (not null) when spend bought no sales; in blended, ACoS and TACoS are null without sales. When the range includes today, same-day ad report rows may not have posted yet (same_day_partial); the blended view includes today live.
get_profit_loss
ChatGPTReturns a profit and loss statement for an account: gross sales, refunds, referral, FBA fulfilment and storage fees, ad spend, reimbursements and net proceeds, plus the seller's own product cost (COGS), fixed costs and India GST where these have been entered in ScaleSKUs. bottom_line is the headline figure; its label says whether it is net profit (ex-GST when a GST slab is set) or contribution before product cost. profit_state: no_costs = contribution before product cost, not profit; partial_costs = some sold SKUs have no cost, so profit is overstated (cogs_coverage gives the costed share); full_costs = net profit. cogs_flag names SKUs that sold without a cost, and alerts lists open profit alerts. Fees are Amazon estimates, typically within 5–10% of settled; data_coverage flags source feeds that are not synced, whose zeros are not real zeros. Optional product views: include_products (10 best and 10 worst), all_products (full paginated list), group_by=parent_asin (variation families) and asins (one combined P&L for the named ASINs). Sponsored Brands spend reaches each product by what its campaigns sold (sb_spend); a campaign that sold nothing stays unattributed. level returns the P&L at another level instead of the statement: day / week / month (a profit table by period), sku, or what each ad earns after it is paid for — campaign, ad_group, keyword (keywords and product targets) or search_term — each with break-even and goal ACoS, profit after ads, a suggested bid (keywords) and search terms to negate or harvest.
get_recommendations
ChatGPTAmazon's own recommendations across the accounts the user manages. One tool, several views (view): account — Amazon's unified account recommendations, by type and status; partner — Amazon's partner opportunity recommendations: objective, advertiser, campaign, current against recommended value. Each view takes the filters marked with its name; the default is account.
get_repeat_purchase
ChatGPTGet Repeat Purchase behaviour (Amazon Brand Analytics, MONTHLY) per ASIN: orders, unique customers, the % of customers who are repeat buyers, and repeat-purchase revenue. For retention, customer-loyalty and LTV analysis and spotting subscribe-&-save or replenishment candidates: "which products keep customers coming back?". Returns the LATEST month by default; pass date_from/date_to (YYYY-MM-DD) for a past month or range (see available_range). Brand-Registry gated; data lags ~1 month.
get_returns
ChatGPTReturns of one account from Amazon's returns reports: units returned and amount refunded, grouped by reason (default), kind (customer return / RTO / damaged in transit), product or day, for a date range. Use it for "what is being returned and why", "how much is RTO vs real customer returns", "which products come back most", or to see whether returns rose after a change. Narrow it with asin or kind. date_basis return_date (default) dates a return by the day it was recorded — counts only, no rate; date_basis order_date dates it by its order's day and gives the return rate of those orders (returned units ÷ units ordered). RTO = undelivered or refused (return to origin) — a delivery problem, not a product problem.
get_reverse_asin_keywords
ChatGPTReverse ASIN keyword lookup: the keywords Amazon suggests for one to five products — the account's own or a competitor's — each with the match types and bid Amazon suggests, the products it came up for, and whether the account already targets it. Use it for "what keywords does this competitor ASIN rank for", "find keywords from my rivals' products", or to find keywords for a new product. It is Amazon's list of keywords relevant to each product, not the keywords that product's seller bids on. Asked of Amazon live: up to 200 keywords a product, in the marketplace of the account; a product Amazon did not answer for is named in not_answered.
get_sales_dips
ChatGPTFind where AD sales dropped and why. Compares a recent period vs a baseline and returns the keywords/targets whose ad sales declined, each with a diagnosed root cause (bid reduced, budget cut, ACoS spike, paused, impressions lost, or UNEXPLAINED). It measures DECLINING AD ENTITIES, not whole-business sales — the returned summary drop is a decliners-only (gross) figure; read net_ad_sales_change for the true net (the account can be UP while this lists dips). UNEXPLAINED = not attributable to ads data (could be organic/price/stock/seasonality). Answers "what is dragging ad sales, and by how much?".
get_search_catalog_performance
ChatGPTGet the per-ASIN organic search funnel from Brand Analytics: search impressions, clicks, click-through rate, cart adds, purchases, conversion rate, search-traffic sales, and median click/purchase price. Use to see how each product performs in Amazon search overall (organic), and where the funnel leaks (impressions but no clicks, or clicks but no purchases). Returns the latest period by default; pass date_from/date_to (YYYY-MM-DD) for a past month/week — history goes back many months (see available_range).
get_search_term_analysis
ChatGPTSearch terms of one account, from the daily search-term reports. One tool, several views (view): analysis — every search term classified (waste, harvest candidate, scaling, neutral) with a suggested action and estimated savings; waste — terms that spent with no order on at least min_clicks clicks, by spend; negatives — candidate negative keywords: spend with no order, or ACoS far over target, with a priority and a reason; harvest — terms converting under a non-exact match that could become exact keywords. Each view takes the filters marked with its name; the default is analysis.
get_shopper_insights
ChatGPTAmazon Marketing Cloud (AMC) shopper-level results for one account, one week (Monday–Sunday, the account's time zone): counts of unique people, which ad reports cannot give. Sections: summary (unique shoppers reached, buyers, buy rate, new-to-brand buyers, ads per shopper, ad-attributed sales incl. brand halo, 14-day); ad_mix (each shopper counted once in the mix of Sponsored Products / Brands / Display they saw, with that mix's buyers and buy rate — how much more shoppers buy after seeing several ad types); trend (the same per week, up to 13 weeks); campaigns (per campaign: unique shoppers reached, ads per shopper, clickers, buyers, new-to-brand buyers and share, spend, sales, cost per buyer); search_terms (search term → the product actually bought, with buyers, new-to-brand buyers, sales of the advertised product and brand-halo sales; purchases only — AMC attributes no detail views or add-to-cart to sponsored-ads search terms); time_to_purchase (share of each ad type's sales by time from ad to purchase: under 1 h … 7–14 days); frequency (shoppers by impressions of each ad type and their buy rate). PLAYBOOKS (pass playbook=…, reads several weeks; sections/week are ignored): Amazon's AMC playbooks run on this account, each returning a headline, findings, suggested actions and its data — clusters (keyword clustering: search terms grouped by the product they sell, the clusters making 80% of sales, converting terms that are not exact keywords yet, terms that spent with no purchase, terms whose shoppers buy a different product than the one advertised); frequency (buy rate by ads seen per shopper for SP/SB/SD, the share of SB/SD impressions reaching shoppers who see too few ads to buy, over-served campaigns); journey (the order shoppers met SP / SB / SD, e.g. "SP > SD", with buy rate and lift vs SP only, plus time from ad to purchase); budget (diminishing-returns curves fitted to each campaign's weekly spend vs sales over 26 weeks: marginal ROAS — what the next unit of spend returns — budget use, and whether to raise budget, raise bids, lower budget or hold, against target_roas); customers (cost per new-to-brand buyer by campaign, weekly new-to-brand trend, gateway products with Brand Analytics repeat rate). An action's suggested_change holds the concrete change it stands for — a new exact keyword, a negative keyword or a new daily budget, with its campaign, ad group and value; actions without one are advice. Weeks become available 2 days after they end; unique counts cannot be added across weeks or rows. Groups below AMC's privacy minimum are merged into one row labelled "Below AMC privacy threshold". status tells when there is no data yet: loading (first weeks importing), terms_required (the Amazon login connected to the account has not accepted the AMC terms), not_available (no AMC account id), not_set_up.
get_sqp_performance
ChatGPTGet Search Query Performance (SQP) data showing organic and paid share metrics per search query. Shows impression share, click share, cart add share, and purchase share for your ASINs against total marketplace volume. Identifies which keywords you rank for organically and where you are missing. Returns the LATEST period by default; pass date_from and date_to (YYYY-MM-DD) to get a specific PAST month/week or a range — historical SQP going back many months is available (see available_range in the response).
get_sqp_share_of_voice
ChatGPTGet brand-wide search-query share of voice: for each search query, your impression/click/cart-add/purchase share of the total market, your query conversion rate, and the paid side (ad spend, sales, ACoS) on the same query — so you see organic vs paid together. Shows queries where the brand converts but under-indexes on impressions (room to scale) and where it holds share but converts weakly (listing or price). Returns the latest period by default; pass date_from/date_to (YYYY-MM-DD) for a past month/week — historical SQP going back many months is available (available_range). view="market" returns the market behind each search instead (monthly first: the latest published month, or weeks when asked or when no month is held): the whole market's searches, clicks and orders and the price shoppers paid, the brand's share of each and its own price, its Sponsored Products and Sponsored Brands ads on the same search, the keywords that target it (exact/phrase/broad, or negated), and the opportunity the figures show with its evidence — harvest (sells, no exact keyword), push (wins more of the orders than of the impressions), cut (ad clicks, no buyer, while the market buys), offer (clicked, bought elsewhere; price above what shoppers paid). opportunity filters to one kind; queries looks up given search terms or keywords. view="tracker" is the 2026 Keyword Tracker: every keyword the brand is found on, one row each — the market's funnel and the brand's with its share at each step, the change in order share on the period before and a 6-month order-share trend, estimated sales and orders without ads, the products that show on it (and the best-selling one), advertised / targeted / not advertised / negated with ad spend, ad sales and ACoS, Amazon's ad impression share and rank, Amazon's search rank of the keyword and whether the brand is one of the 3 most-clicked products; lane picks a view (tracked = the user's starred keywords), asin narrows it to one product. view="keyword" with keyword is one keyword in depth: its last 12 weeks, the brand's products on it, the top 3 clicked products month by month, the keywords and campaigns on it, what changed on them (Amazon's change history) and the account's notes.
get_started
ChatGPTReturns an orientation for a new or unsure user: a plain-language welcome and how ScaleSKUs works, a live snapshot of the account (whether its data is ready; the last 30 days of ad spend, ad sales, ACoS, total sales and TACoS in the account currency), the one suggested first step for this account (from its numbers and what has already been run), progress along a four-stage learning path, and short example requests grouped by stage (cut waste, grow sales, fix bids, budgets, why sales dropped, full review). Fits greetings and questions like "what can you do?", "where do I start?" or "I'm new". With node, returns the expert reasoning behind one optimization lever instead: the questions to settle, recommended standards, how the decision is reasoned, the data it reads, deeper sub-levers and the workflow that runs it; the negatives lever also lists live wasted-spend candidates with fit and price signals when profile_id is given. Read-only.
get_sync_status
ChatGPTReports whether the user's Amazon data is synced and up to date across Amazon Ads, SP-API and report data. overall_status is one of: fresh (up to date), syncing (catching up), initializing (first-time setup, no data yet), stale (data behind) or disconnected (needs reconnect); is_alert is true only for stale and disconnected. Without profile_id it returns a lean roll-up across every account the user can access (counts plus the stale and initializing shortlists); with profile_id it returns full detail for that account. last_data_date and fresh_days are advertising-scoped (data_scope="advertising_reports"); retail has its own retail_data_date. For a single account, a coverage block gives freshness per source, each judged against its own normal lag: advertising reports (SP, SB, SD; expected through yesterday), today's live stream (provisional), and retail (the Sales & Traffic business report, which normally lags 2-3 days, plus the Sales API backfill of recent days). Each source's status is current, delayed, no_data or unknown, and advertising and retail each carry their own summary status; a source at its normal lag is current, not stale.
get_table_views
ChatGPTLists the saved views of ScaleSKUs' tables (Campaigns, Ad groups, Targets, Search terms, Products, Tasks and the rest) the signed-in user can open: their own, and those their team shared — each view's id, name, the filters, search and sort it keeps, and whether it is shared and by whom. These are the "My views" and "Team views" in each table's Views panel; a view opens on any account, on the dates in view. Without table it also lists every table a view can be made of and the settings each one keeps, by key — what a new view of that table can hold. With profile_id each view carries an open_url to that account's table.
get_target_performance
ChatGPTProduct, category, audience and automatic targets of one account. One tool, several views (view): performance — per-target impressions, clicks, spend, sales, orders, ACoS, ROAS, CTR, CPC and CVR (Sponsored Products, Brands and Display); efficiency — the same targets labelled by efficiency, each with a suggested bid. Each view takes the filters marked with its name; the default is performance.
get_tasks
ChatGPTList team tasks for the organization: title, type, priority, status, assignee, due date and whether overdue, plus KPI counts (open, in progress, completed today, overdue). Optionally filter to one account. Agency-internal.
get_taxonomy_benchmarks
ChatGPTReturns Sponsored Products advertising performance per catalogue node — level sub_category (default), category or asin — over the last N days (default 30, range 7-90), from the daily advertised-product reports: products, spend and share of spend, sales, orders, clicks, ACoS, CVR, CPC, CTR and average order value. Nodes are the top N by spend (default 25, at most 100); spend share is relative to the nodes returned, and ratios are null when their denominator is 0. Answers questions like "which product groups convert at very different rates (say 4% vs 12%), and so need different automation thresholds?". Nodes come from the account's product taxonomy; "(category unknown)" groups advertised products not placed yet.
get_watchlist
ChatGPTReturns an account's watchlists in ScaleSKUs: the named lists of campaigns, keywords, targets, search terms and ASINs its people chose to follow. With a watchlist_id (or when the account has one list) it returns that list's items, each with ad-attributed sales, spend, orders, ACoS, ROAS, clicks, CTR, CVR, CPC and impressions for the last 1, 7, 14 or 30 complete days, the same metrics for the period before, and the change (% for amounts, percentage points for ACoS / CTR / CVR). With movers_item_id it also returns what rose and fell behind that one item: for an ASIN the keywords, targets and search terms of the ad groups that advertise it (ad groups shared with other products are counted in shared_ad_groups, so those targets are not that product's alone); for a campaign its keywords, targets and search terms; for a keyword or target the search terms it matched; for a search term the keywords and targets that matched it. ACoS is null when there were no attributed sales. Windows end on the account's last complete day, so today is not included. Read-only.
harvest_keyword
ChatGPTSponsored Products only. Adds a converting search term as a keyword (EXACT default, PHRASE or BROAD), or an ASIN as a product target, to an ad group of a MANUAL campaign. A bid given is used as given. With no bid, nothing is queued: the result is needs_bid with Amazon's suggested bid for it there (suggested_bid) — ask the user what bid they want and call again with bid, or with use_suggested_bid=true when the user says to use Amazon's suggestion. The response lists warnings when the ad group advertises a different product than the term sells, the term is negated there, the product's price is well above what buyers of that query pay, or the destination is one Amazon rejects (an automatic campaign, an ad group of another campaign, or one holding the other kind of targeting); a rejected destination fails on execution. With source_campaign_id (where the term converted), once the keyword is live a negative is added in the source so it stops bidding on the same term: an exact negative keyword at campaign level (another campaign) or ad-group level (same campaign), or for an ASIN a negative product target in the source ad group; negate_source=false skips it. By default the change is saved as a pending task for approval. mode="execute" applies it to Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login; otherwise it is saved as a pending task. To make many changes at once, pass items: a list of up to 1000 changes, each with this tool's own arguments — one call instead of one per change; an argument given beside items (a campaign, a match type, a reason) applies to every item unless the item sets its own. Each item gets the same checks and its own task; with mode="execute" they are applied together, and the answer gives every item's outcome. A long list is taken as far as one call's time allows: continue_from then names the item to send on from, in another call.
list_automation_library
ChatGPTReturns automation recipes set from the account's own numbers — waste negatives, bid trims over target ACoS, zero-order cuts, bid raises on under-target winners, budget top-ups while profitable. Thresholds come from the chosen scope (asins, sub_categories, categories or portfolio_ids; none = the whole account): its conversion rate sets how many clicks are enough to judge, its order value and target ACoS how much spend is too much, its CPC the bid floor and ceiling. The target ACoS is the one given, else the account strategy's, else the scope's own ACoS; the answer says which. Under 200 clicks in the scope, the thresholds lean on defaults. Each recipe is a complete automation-rule draft (scope included) with the reason for each threshold. Read-only: nothing is created.
list_creative_assets
ChatGPTLists the account's Amazon Creative Asset Library: the images, brand logos and videos uploaded once and reused in Sponsored Display and Sponsored Brands creatives, such as the optional brand logo shown with a Sponsored Display headline. Read live from the Amazon Ads API; nothing is stored in ScaleSKUs, and an API or connection error returns an empty or partial list rather than an error, so total=0 can also mean the library could not be read. Per asset: asset_id, name, type (IMAGE or VIDEO), sub_types, dimensions, size_kb, url (full size), thumbnail_url (500px) and is_logo_candidate. Logo candidates sort first, then larger assets. is_logo_candidate is true for an IMAGE with a LOGO subtype, or one that is near-square (width/height 0.8–1.25) with both sides at least 400px; Amazon tags most seller uploads OTHER_IMAGE, so geometry decides. Also returns total and logo_candidates counts and a note.
list_data_tables
ChatGPTLists the analytics tables open to analysis, with approximate row counts. Only Amazon-data tables are included (ads reports, master entities, stream, rollups, intelligence, SP-API retail, Brand Analytics, catalog); internal and secret tables are not. approx_rows is MySQL's estimate and reads 0 for tables served as row-filtered views. Optional name-substring filter; up to 200 tables by default, 500 at most.
list_profiles
ChatGPTLists the Amazon Ads accounts (profiles) the user can access, sorted by name, one row per account. Each profile_id is an opaque handle (e.g. "prf_XP3fCAtjeKyE"), not Amazon's numeric id; the handle is the account's id everywhere in ScaleSKUs. Rows are lean by default (profile_id, name, country, currency, type, ad_account_type, advertise_by, is_active, is_stale, days_behind); advertise_by is how the account names a product in an ad — SKU for a seller ad account, ASIN for a vendor ad account; include_details=true adds active, last_synced, last_data_date, sync_status and freshness_note. Paginated (100 per page by default, at most 200) with total_count and has_more. Only active profiles unless active_only=false. is_stale, days_behind and last_data_date reflect advertising report coverage only; retail (business report) and Sales API data keep their own freshness, which this list does not show.
list_sheet_reports
ChatGPTLists the automated sheet reports (Google Sheets, and Excel workbooks) set up in this workspace: for each, the report_id, title, status (active, paused, needs_google, needs_microsoft, no_access, failing), schedule, mode (replace / rolling / append), destination (excel for an Excel workbook; a Google Sheet otherwise), sheet URL, next and last run, rows written and the last error. Agency full-access users see every report of the workspace; others see their own.
memory_forget
ChatGPTArchives a saved team memory inside ScaleSKUs by its id, so it no longer appears in recall, the timeline or the team summary. This is a soft delete: the record is kept with status archived, not permanently erased. Only memories within the caller's organization and account access can be archived.
memory_recall
ChatGPTSearch the shared, cross-platform team memory by keyword (matches title, content, and rationale) with optional filters. For questions about past decisions and the reasoning behind them, prior discussions, or how and why a campaign was set up. Filter by memory_type, profile_id (one account), entity_id, tag, or source.
memory_remember
ChatGPTSaves a note the user asks to keep to the organization's team memory, which is stored inside ScaleSKUs; members of the same organization can read it back in later sessions. A note records what happened and why: a decision and its rationale, a discussion, meeting minutes, a rule or target the brand owner or team set, a campaign that was created and its logic, an open follow-up item, a fact, or a preference. memory_type: decision | discussion | search | campaign_event | action | fact | preference | note (default) | instruction (a rule or target the team set) | meeting (minutes) | open_item (follow-up). With profile_id the memory is about one account; without it the memory is org-wide. context holds structured details such as campaign_id, asin, metrics or logic. Returns the stored memory with its id.
memory_timeline
ChatGPTThe shared team memory in chronological order — what happened and when (decisions taken, campaigns created, searches run, notes). Filter by memory_type, profile_id (one account), entity_id, and a since/until date window. Reconstructs the history: "what did we change on this account and why", "what was decided last week".
preview_automation
ChatGPTDry-runs an automation rule draft against the account as it is now; nothing is saved or changed. Takes the same fields as a new automation rule (entity_type, conditions, action, scope, policy). Returns how many entities match right now; a sample of the changes (current → new value, what the task checks say — already live, another automation owns it, a person rejected it …, the 0–100 confidence with why, and whether it would run on its own under the policy or wait for approval); a rule that already does exactly this; overlaps with other automations; and, for a product scope, which campaigns are generic, with reasons.
read_guide
ChatGPTReturns the text of one ScaleSKUs reference guide by guide_id, or one section of it, with the guide's version, updated_at and section outline. Examples: "metrics" (ACoS, TACoS, settled attribution), "data-dictionary" (tables, columns, example SQL), "answering-guide", and "tool:<tool_name>" for one tool (what it does and every input, with each field's type, allowed values and limits — the agency team also gets worked examples). Guides over about 12,000 characters return their outline and introduction (truncated: true); a named section returns that section. An unknown guide_id or section returns an error listing the valid ids or section headings.
remove_from_watchlist
ChatGPTTakes items off one of an account's watchlists in ScaleSKUs, by their item_id values. Only the bookmarks go: the campaigns, keywords, targets, search terms and products themselves are untouched, nothing is sent to Amazon, and an item can be added again. The list itself stays, even when it ends up empty. Returns how many items were removed.
review_automation
ChatGPTRecords a review of an automation rule (verdict keep, tune, pause or retire, with a one-line note of the evidence), stores the rule's last 14 days of performance with it, and schedules the next review (cadence_days, default 7). tune: the changes (conditions, action, scope, priority, cooldown_hours, policy, rule_name, description) become a pending task on the ScaleSKUs Tasks page and apply as the rule's next version once approved; with user_confirmed=true they apply immediately. pause: pauses the rule, which stops at its next check. retire: with user_confirmed=true, deletes the rule (a copy stays in its version history; the deletion cannot be undone from here); without it the rule is only paused. A rule that had dropped to approval mode because its review was more than 7 days overdue returns to acting on its own after a keep or tune review.
run_analysis_query
ChatGPTRun a read-only SQL SELECT against ScaleSKUs' analytics database (MySQL 8), which holds the Amazon Ads, Seller/Vendor Central and Brand Analytics data ScaleSKUs syncs. For custom analysis: joins, cohorts, aggregations, cross-table comparisons. Limits: one SELECT or WITH statement; writes, DDL, @variables, comma joins (FROM a, b) and other schemas are rejected. Only Amazon-data tables are queryable (ads reports, master entities, stream, rollups, intelligence, SP-API, Brand Analytics, catalog). Default 500 rows, max 5,000, 15-second limit; a missing LIMIT is appended and truncated marks a cut. Agency full-access tokens read unfiltered data, so profile_id selects the account; other tokens see only their accounts' rows. Handles in the SQL (prf_…, cmp_…) become real ids; id columns in results return as handles. Conventions: ad totals span reports_{sp,sb,sd}_campaigns_daily; spend is cost. SP campaign, search-term, target and placement reports use sales_7d/purchases_7d (vendors: sales_14d/purchases_14d); SP keywords, SP advertised products and all SB/SD use sales/purchases. reports_sp_targets_daily has no target_id: it is in keyword_id (expression in targeting), matching master_sp_targets.target_id. Ads top-of-search share: top_of_search_impression_share (SP campaign/target/placement, SB campaign reports); query-level share: asin_impression_share / asin_purchase_share in sp_api_sqp_weekly/monthly, with search_query_volume. Account total sales (TACoS base): sp_api_daily_summary.ordered_product_sales; per-ASIN sp_api_business_reports rows are not an account total. No table holds COGS or net profit. Fact tables use date, not report_date. Master tables can repeat an entity across connections (the freshest updated_at is current). stream_ tables cover today; reports__daily run through yesterday.
run_sheet_report
ChatGPTRuns an automated Google Sheet report once, immediately, by report_id, and keeps its schedule. The report's query is run again and the result is written to its sheet in the user's Google Drive in the report's mode: replace rewrites the tab, rolling rewrites the dates returned, append adds rows below the previous ones. Returns the run's status and message, the rows written and the sheet URL.
run_workflow
ChatGPTRuns a complete expert workflow on an account in a single run, for a short or goal-style request. Workflows and the requests they cover: cut_waste (wasted spend, reduce ACoS, negatives); harvest_winners (new keywords, grow sales, scale winners); fix_bids (bids on high-ACoS keywords and efficient winners); uncap_budgets (running out of budget); sales_drop (why sales are down); health_check (how the account is doing); stock_leak (out-of-stock or suppressed products still spending); profit_leaks (where profit leaks: products losing money after fees, refunds and ads, RTO, returns, cancellations); customer_experience (ratings, return reasons, account health, Seller Central alerts); placements (top of search, placements); market_share (competitors, search share); measure_results (whether changes worked); weekly_review (optimize the account, what to do next). A free-text request is matched to the closest workflow; an unclear one returns options. Returns a headline with the money at stake, evidence, caveats and a numbered plan of ready-made changes, each with the reason and number behind it; negate and harvest items carry fit evidence and are marked check_fit_first. The plan is saved in ScaleSKUs under a plan_ref for 7 days, and the run counts toward the account's getting-started progress. Nothing changes on Amazon and no task is created. An account still on its first sync gets data_not_ready and no plan. Full reviews scan weeks of data and can take 10-40 seconds.
schedule_sheet_report
ChatGPTSets up an automated Google Sheet report: a read-only SQL SELECT over ScaleSKUs' analytics database (MySQL 8) that the ScaleSKUs server re-runs on a schedule — hourly, daily, weekly or monthly at a set local time — and writes to a sheet in the user's own Google Drive. mode="replace" rewrites the tab each run with the latest result; mode="rolling" (with date_column) rewrites only the dates each run returns and keeps all older rows — for day-by-day reports whose recent days are restated; mode="append" adds each run's rows below the previous ones, with a synced_at column first. The response includes data_rules for the tables the query reads: how each is re-filled and resync_days, the trailing days a recurring query on them re-reads each run. The first run happens immediately: it creates the sheet and checks the query, and nothing is saved when it fails. Returns the report_id, the sheet URL, the schedule and the next run. Same query rules and row scope as the analytics query tool (one SELECT or WITH statement over Amazon-data tables; the user's own accounts only); each run re-checks the owner's access. Up to 50,000 rows per run. Before saving, the query is checked for mistakes that make report numbers wrong (no account filter, inventory summed across snapshots, per-ASIN sessions as an account total, wrong attribution column, yesterday's traffic shown as 0, a window shorter than the sources' restatement window …): check_only=true returns those checks with 10 sample rows and saves nothing; a check of level "error" stops scheduling (status needs_fix) unless acknowledge_checks=true. Needs the user's Google account connected once; when it is not, the status is needs_google_connection with a connect_url. destination="excel" writes the report to an Excel workbook (.xlsx) in the user's own OneDrive instead, in the same modes; it needs the user's Microsoft account connected once (status needs_microsoft_connection with a connect_url when it is not).
search_guides
ChatGPTSearches ScaleSKUs' reference guides by keyword and returns the best-matching sections, ranked: guide_id, section heading and a short snippet for each — bounded snippets, not full text. Answers lookups like "how is TACoS defined", "settled attribution window", "impression share column" or "how to find wasted spend". Words under 3 characters are ignored; only the guides visible to the caller are searched.
set_automation_state
ChatGPTPauses, enables or deletes an automation rule. state="paused": the rule stops at its next check; allowed at any time, and nothing it already changed is undone. state="active": the rule starts changing the account on its schedule, under its policy. Requires user_confirmed=true (otherwise the result is needs_ack and nothing changes); refused when the rule engine cannot run the rule as written; returns needs_ack when another active automation performs the same operation on the same campaigns, unless acknowledge_overlap=true. state="deleted": requires user_confirmed=true; removes the rule, which cannot be undone from here (a copy stays in its version history). Changes it already made stay.
set_base_budgets
ChatGPTReads and sets the base budgets of an account's enabled campaigns (Sponsored Products, Brands and Display). A campaign's base budget is the daily budget it returns to: a budget rule raises a campaign to at most a multiple of its base, and with auto_reset on, the campaign's budget on Amazon is put back to the base at midnight on the account's clock. With campaign_ids and base_budget, that amount becomes the base of each campaign named; with campaign_ids alone, each takes today's budget as its base; items gives each campaign its own base in one call (a different amount per campaign, up to 1000); fill_missing=true gives every enabled campaign that has no base today's budget as its base; remove=true with campaign_ids takes the base off those campaigns (no midnight reset for them any more; today's budget is not touched). With none of these, nothing changes and the result is the current state. To keep daily budgets the user just changed for today, save them as the bases: items with each campaign's new amount, or campaign_ids alone (each takes today's budget) — otherwise the midnight reset puts each campaign with auto_reset back to its old base. distribute splits a daily total across the enabled campaigns by the ad sales each brought over the last window_days complete days, once, like the page's "Distribute by sales": it previews the split, and with distribute.apply=true writes it as the bases (auto_reset on; the midnight reset sends them to Amazon, or apply_now=true now). Use schedule to repeat it automatically. A new base has auto_reset on unless auto_reset=false; passing auto_reset changes it on the campaigns named. On its own, setting a base does not change today's budget on Amazon; the next midnight reset does when auto_reset is on and the budget differs from the base. apply_now=true also makes the base the live budget: each campaign named (every enabled campaign with a base when none is named) whose budget on Amazon differs from its base gets a budget change to the base. By default these are saved as pending tasks for approval; mode="execute" applies them to Amazon immediately when two-factor authentication is on for the user's ScaleSKUs login, and where the account is set to approval first they stay pending. schedule redistributes the base budgets by sales automatically, as on the Base budgets page: on the days it names (daily, a weekday or a day of the month) at 23:30 on the account's clock it shares the daily total (today's total of the bases, or a fixed amount) across the enabled campaigns by the ad sales each brought over the last window_days complete days, each campaign keeping the currency minimum, a campaign under 14 days old keeping its budget, and no campaign moving more than max_change_pct in one run; it writes the bases with auto_reset on and the midnight reset sends them to Amazon (plan_only=true only emails the plan). schedule.action: "read" (default) lists the account's schedules, "preview" shows the split these settings would make tonight without saving, "set" creates the schedule for those campaign types or changes the one there is, "pause", "resume", "delete" act on the schedule for schedule.ad_product. One schedule per set of campaigns: ALL covers SP, SB and SD. The result holds the campaigns changed, a summary (enabled campaigns, with a base, without, auto-reset on, today's total budget, total base) and the campaigns that still have no base. Accounts whose changes_allowed is "manual" or "read_only" refuse a change (automation_off_for_account).
set_dayparting_state
ChatGPTEnables, pauses or deletes a day-parting schedule. state="paused": stops it now and puts every bid, budget or campaign status it changed back to its base value; allowed at any time. state="active": the schedule starts changing the account at the next window boundary (within about 5 minutes). Requires user_confirmed=true, otherwise the result is needs_ack and nothing changes. If another enabled schedule sets the same bids, budgets or campaign status, the result is needs_ack listing it (the two would keep overwriting each other), unless acknowledge_conflicts=true.
set_product_costs
ChatGPTSaves per-SKU product costs into an account's P&L in ScaleSKUs: COGS, any custom per-unit cost columns (e.g. "Inbound freight", "Packaging") and an optional India GST slab % per product, so the P&L can show net profit, and sales and COGS with and without GST. It writes the user's own cost data in ScaleSKUs: nothing is sent to Amazon, the change applies immediately with no approval task, and it is available on read-only connections. A CSV or Excel cost sheet is imported by passing its rows (there is no file parameter); the result matches the P&L page's cost upload. Each row keys on sku (matched first) or asin (mapped to the account's SKUs for that ASIN), with a costs object such as {"COGS": 142.5, "Inbound freight": 8} and an optional gst_rate (e.g. 18). Merge semantics: missing cost columns are created; only the SKUs, columns and GST rates sent are updated, overwriting their previous values; everything else is kept. Cells parse leniently ("18%" → 18, "1,500/-" → 1500). Returns the SKUs written, created and updated, new columns and any unmatched ASINs.
set_product_taxonomy
ChatGPTAssigns products (ASINs, up to 1,000) to a sub_category, optionally with category, department and leaf, in the account's ScaleSKUs product taxonomy. An existing sub-category name joins it; a new name creates one. The assignment overrides the automatic placement, is kept through taxonomy rebuilds, and is used by product-scoped automation rules and by campaign-structure classification (specific vs mixed), which is recomputed immediately. clear=true removes the override so the automatic placement applies again. Takes effect at once, with no task or approval, and changes nothing on Amazon.
set_watchlist_alert
ChatGPTSets the sales-drop alert of one watchlist in ScaleSKUs: at the times of day the user chooses, each item's sales are compared with its usual day (its average daily sales over the last 60 days), and the user is told on WhatsApp and by email which items are under it by at least drop_percent. Two comparisons: yesterday as a whole, told once a day; and today so far against what the account has usually sold by the same hour, told at each check time. A product (ASIN) of a seller account is compared on total sales, ads and organic, read every 15 minutes; a campaign, keyword, target or search term, and a vendor account's product, on ad sales for yesterday only. The percentage and the check times are the user's choice: ask for them when they were not stated. A watchlist has one alert; calling again changes only the settings passed, and enabled=false stops it. The result holds the alert, whether WhatsApp can reach this user, and a comparison of every item right now. This is a notification setting: nothing is sent to Amazon and no ad, bid or budget changes.
share_table_view
ChatGPTShares one of the signed-in user's saved views of a ScaleSKUs table with their team — everyone in the workspace then sees it under Team views on every account — or, with shared=false, stops sharing a view they shared, which goes back to their own views. Only the person who shared a view can stop sharing it. Nothing is sent to Amazon.
update_ad_group
ChatGPTEdits an ad group: its name, its default bid — what its keywords and targets without a bid of their own pay — and/or its status (pause it or switch it back on). What is not passed keeps its current value. By default each change is saved as a pending task for approval. mode="execute" applies it to Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login; otherwise it is saved as a pending task. To make many changes at once, pass items: a list of up to 1000 changes, each with this tool's own arguments — one call instead of one per change; an argument given beside items (a campaign, a match type, a reason) applies to every item unless the item sets its own. Each item gets the same checks and its own task; with mode="execute" they are applied together, and the answer gives every item's outcome. A long list is taken as far as one call's time allows: continue_from then names the item to send on from, in another call.
update_automation_rule
ChatGPTChanges an existing automation rule. Only the fields passed change: rule_name, description, conditions (replaces them all), action (replaces it), scope (replaces it), schedule (replaces it), target_entity_status, is_one_time, ends_on (null takes the end off), priority, cooldown_hours, policy (merged onto the current one), account_gate (replaces it; null removes it). Uses the same vocabulary and checks as rule creation. A running rule changes only with user_confirmed=true; without it the result is needs_ack listing the changes, and nothing is saved. A change that would make the rule identical to another rule is refused; one that creates an overlap with another active automation on the same operation returns needs_ack unless acknowledge_overlap=true. Every change is saved in the rule's version history with who made it; a running rule uses the change from its next check.
update_campaign
ChatGPTEdits a campaign: its name, its daily budget, its status (pause it, switch it back on, or archive it — permanent, only with the user's confirmation), its portfolio (move it into one, or out with "none"), its start and end dates, and — on Sponsored Products — its placement bid adjustments (Top of Search, Product Pages and/or Rest of Search, each 0–900%, e.g. 50 = +50%), its bidding strategy (dynamic bids down only, dynamic bids up and down, or fixed bids) and an audience bid adjustment (0–900% for one Amazon audience). What is not passed keeps its current value. By default the change is saved as a pending task for approval. mode="execute" applies it to Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login; otherwise it is saved as a pending task. To make many changes at once, pass items: a list of up to 1000 changes, each with this tool's own arguments — one call instead of one per change; an argument given beside items (a campaign, a match type, a reason) applies to every item unless the item sets its own. Each item gets the same checks and its own task; with mode="execute" they are applied together, and the answer gives every item's outcome. A long list is taken as far as one call's time allows: continue_from then names the item to send on from, in another call.
update_keyword
ChatGPTEdits a keyword: its bid, its status (pause it or switch it back on) and its match type. Amazon does not change the match type of a keyword that exists, so a new match type is made as a new keyword with the same text and bid in the same ad group, and the old keyword is paused — two changes. What is not passed keeps its current value. By default each change is saved as a pending task for approval. mode="execute" applies it to Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login; otherwise it is saved as a pending task. To make many changes at once, pass items: a list of up to 1000 changes, each with this tool's own arguments — one call instead of one per change; an argument given beside items (a campaign, a match type, a reason) applies to every item unless the item sets its own. Each item gets the same checks and its own task; with mode="execute" they are applied together, and the answer gives every item's outcome. A long list is taken as far as one call's time allows: continue_from then names the item to send on from, in another call.
update_listing
ChatGPTChanges a seller's Amazon listing — the complete SEO side of it, one SKU at a time, through the account's Seller Central connection: title (item_name), bullet points, description, search terms (generic_keyword), and every other attribute Amazon's definition of the product type puts under product details (special features, material, colour, size, style, department, target gender, item type name, pattern, theme, scent, included components, …) plus the browse node and model name. Also variations, brand, manufacturer and product ids, dimensions and weight, safety and compliance, and the stock of a self-shipped listing (fulfillment_availability) — Amazon's check runs for these everywhere; they are saved once ScaleSKUs has proven each kind on its own listing. Not a price (list, sale, business or quantity prices), images, or the rest of the offer (condition, tax code, handling time, shipping template). mode="check" tests the parts given against Amazon's rules and Amazon's own validation; nothing is saved. mode="task" (default) saves each part that passes as a pending task for approval in ScaleSKUs; mode="execute" also applies it where listing saves are enabled for the account and two-factor authentication is on, otherwise it stays a pending task. Vendor Central listings are not covered.
update_portfolio
ChatGPTChanges portfolios: their budget cap and, for one portfolio, its name. budget_policy NO_CAP removes the cap (the portfolio no longer limits its campaigns' spend; each campaign's own daily budget still applies); DATE_RANGE caps spend at budget_amount between start_date and end_date; MONTHLY_RECURRING caps it at budget_amount each month. Up to 1,000 portfolios in one call (the account's portfolio list gives their ids); a portfolio already as asked is left out. Campaign budgets and statuses are not touched. By default each change is saved as a pending task for approval. mode="execute" applies them to Amazon together immediately if two-factor authentication is on for the user's ScaleSKUs login; otherwise they are saved as pending tasks.
update_product_ad
ChatGPTPauses a product ad — an advertised ASIN or SKU — or switches it back on (Sponsored Products). Name it by its handle, or by ASIN or SKU, optionally within one campaign. What is not passed keeps its current value. When an ASIN's ads advertise more than one SKU, nothing is changed until the SKU is named or confirm_all_skus=true is passed: the result lists each SKU with what is known of its stock. By default each change is saved as a pending task for approval. mode="execute" applies it to Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login; otherwise it is saved as a pending task. To make many changes at once, pass items: a list of up to 1000 changes, each with this tool's own arguments — one call instead of one per change; an argument given beside items (a campaign, a match type, a reason) applies to every item unless the item sets its own. Each item gets the same checks and its own task; with mode="execute" they are applied together, and the answer gives every item's outcome. A long list is taken as far as one call's time allows: continue_from then names the item to send on from, in another call.
update_target
ChatGPTEdits a product target or an automatic-targeting group: its bid and/or its status (pause it or switch it back on). A target has no match type: what it targets is fixed when it is made — to target something else, create a new target and pause this one. What is not passed keeps its current value. By default each change is saved as a pending task for approval. mode="execute" applies it to Amazon immediately if two-factor authentication is on for the user's ScaleSKUs login; otherwise it is saved as a pending task. To make many changes at once, pass items: a list of up to 1000 changes, each with this tool's own arguments — one call instead of one per change; an argument given beside items (a campaign, a match type, a reason) applies to every item unless the item sets its own. Each item gets the same checks and its own task; with mode="execute" they are applied together, and the answer gives every item's outcome. A long list is taken as far as one call's time allows: continue_from then names the item to send on from, in another call.
