The automation language

Rules are written in a small, readable language built for Amazon Ads: loop over an entity, check conditions on its metrics, call actions. The editor has syntax highlighting, autocomplete, inline error checking, and a built-in reference; every run is recorded and revertible.

The basic shape

Bodies are indented two spaces. Keywords, entities, fields, and functions are case-insensitive.

Entities you can loop over

Hop to related entities with a dot: keyword.campaign, searchTerm.adGroup, campaign.portfolio, campaign.placement. Related objects can be named: LET campaign = keyword.campaign.

Inside the row you already have: child loops

A FOR EACH written inside a block reads what is inside the row it is standing on. Where the outer loop says which table to read, the child loop names a parent object, and the rows it hands back are ordinary rows, with the same fields, metrics and actions they have in a top-level loop.

This is what lets one rule cross two dimensions. "A campaign for every proven search term and every proven ASIN in its ad group" is one loop inside another:

# ALLOW CREATION
FOR EACH searchTerm IN LAST 90 DAYS:
  IF searchTerm.orders > 25 AND searchTerm.acos < 20%:
    FOR EACH product IN searchTerm.adGroup OVER LAST 30 DAYS:
      IF product.orders > 5:
        LET name = CONCAT("MD, ", product.asin, ", ", searchTerm.searchTerm)
        LET camp = createCampaign(name, budget: $10, targeting: "manual", portfolio: createPortfolio("MerchDash"))
        LET ag = camp.createAdGroup(name, $0.25)
        ag.addAsin(product.asin)
        ag.createKeyword(searchTerm.searchTerm, "exact", $0.25)
    END
END

A child loop iterates what is in the ad group right now, from the same snapshot the Campaigns pages read, not only what Amazon reported activity for. Metrics on those rows are read for the window in force, so an ASIN that never delivered reads zero rather than disappearing.

One campaign or ad group, by name

A child loop can also open a rule. Look the parent up in a LET, then name it after IN, no outer loop, and nothing else in the account is read:

LET camp = FIND_CAMPAIGN("Brand - Exact")
FOR EACH keyword IN camp OVER 8..35:
  IF keyword.clicks >= 10 AND keyword.orders = 0:
    keyword.setBid(MAX($0.05, keyword.bid * 0.85))
END

Check one thing, then the next: ELSE and SET

A rule can look in one place, and only if that finds nothing look in another. ELSE IF and ELSE sit directly under an IF, at its indentation, and only one branch of the chain runs. SET carries a value out of a loop: declare a counter with LET, add to it inside the child loop, read it after the loop.

FOR EACH product IN LAST 30 DAYS:
  IF product.acos > 70%:
    LET ag = product.adGroup
    LET wasteful = 0
    FOR EACH searchTerm IN ag OVER LAST 30 DAYS:
      IF searchTerm.cost >= $5 AND searchTerm.orders = 0:
        searchTerm.addNegative(searchTerm.searchTerm)
        SET wasteful = wasteful + 1
    END
    IF wasteful > 0:
      log("{asin}: {wasteful} wasteful search terms negated")
    ELSE:
      LET checked = 0
      LET weak = 0
      FOR EACH keyword IN ag OVER LAST 30 DAYS:
        SET checked = checked + 1
        IF keyword.cost >= $5 AND keyword.orders = 0:
          keyword.setBid(MAX($0.05, keyword.bid * 0.8))
          SET weak = weak + 1
      END
      IF checked > 0 AND weak = 0:
        product.setState("PAUSED")
END

Amazon's suggestions: keywords and product targets

Amazon suggests keywords for an ad group and products to target for an ASIN. A rule can read those suggestions as a child loop and decide what to do with each one, the same suggestions the console shows, with the bid Amazon would start at:

FOR EACH adGroup IN LAST 30 DAYS:
  IF adGroup.orders >= 3 AND adGroup.acos < 25%:
    FOR EACH suggestedKeyword IN adGroup:
      IF suggestedKeyword.matchType = "EXACT" AND suggestedKeyword.rank <= 10 AND NOT suggestedKeyword.alreadyTargeted:
        adGroup.createKeyword(suggestedKeyword.keywordText, "exact", MIN(suggestedKeyword.bid, $1.00))
        adGroup.note("Amazon suggests it, rank {suggestedKeyword.rank}")
    END
END

Products work the same way. suggestedAsin is asked for the ASINs the ad group advertises, and a product target is created with createTarget:

FOR EACH adGroup IN LAST 30 DAYS:
  IF adGroup.orders >= 3:
    FOR EACH suggestedAsin IN adGroup:
      IF suggestedAsin.rank <= 5 AND NOT suggestedAsin.alreadyTargeted AND NOT HAS_ASIN(adGroup, suggestedAsin.asin):
        adGroup.createTarget(PRODUCT_TARGET(suggestedAsin.asin))
    END
END

Across every campaign: accumulated reports

A keyword row is one keyword in one ad group, and a product row is one ad in one campaign. So a keyword that looks acceptable in each of ten campaigns, but has quietly spent $40 with no orders across all of them, is invisible to an ordinary loop. An accumulated report is the rollup the Accumulated tabs show, built for the run and iterated like any other entity:

CREATE ACCUMULATED KEYWORD REPORT IN LAST 60 DAYS

FOR EACH accumulated_keyword:
  IF accumulated_keyword.spend >= $40 AND accumulated_keyword.orders = 0:
    accumulated_keyword.pauseEverywhere()
    accumulated_keyword.note("{spend:money} across {campaigns} campaigns, no orders")
END

The same works for ASINs with CREATE ACCUMULATED ASIN REPORT and FOR EACH accumulated_asin. The report exists only for that run, nothing appears under Reports.

Fields. Every metric, plus keywordText, matchType, asin, sku, the counts campaigns / adGroups / keywords / ads, their live and paused halves in full, live_keywords / paused_keywords, live_ads / paused_ads, live_campaigns / paused_campaigns, live_ad_groups / paused_ad_groups, and keyword_state / asin_state, ENABLED when anything can still deliver, PAUSED when nothing can. Both spellings work: live_keywords and liveKeywords. An ASIN row also splits its ads by ad product: sp_ads is the Sponsored Products share of ads, and sb_ads counts the Sponsored Brands ads whose creative features the ASIN right now, a snapshot that is not part of ads and carries no metrics of its own, because Amazon publishes no per-ASIN reporting for Sponsored Brands (why).

Accumulated rows carry one metric the per-entity loops don’t: cpo, cost per order (spend ÷ orders). Like every ratio it has no value when the denominator is zero, so a row with no orders is skipped by a numeric comparison rather than matching as infinity.

Actions say how far they reach. One row is many real entities, so pause() does not apply to it, use pauseEverywhere(), setBidEverywhere(v) or negateEverywhere([match]). Each acts on every instance that delivered in the report's window and is still enabled, and each writes ordinary History entries you can revert.

Acting on a proven ASIN's bids

An ASIN has no bid. A bid lives on the keywords and targets that advertise it, which is why there is no setBidEverywhere() for an ASIN, and never will be. An ASIN row therefore has child loops: they iterate what that ASIN delivered through inside the report's timeframe, as ordinary rows you can read and act on. Everything it ran in is handed back, so the report decides which ASINs and the rule decides what to touch.

CREATE ACCUMULATED ASIN REPORT IN LAST 60 DAYS

FOR EACH accumulated_asin:
  IF accumulated_asin.orders > 10 AND accumulated_asin.cpo < $2.50:
    FOR EACH keyword IN accumulated_asin:
      IF keyword.state = "ENABLED":
        keyword.setBid(MIN($1.50, keyword.bid * 1.10))
        keyword.note("ASIN {accumulated_asin.asin} proven across campaigns")
    END
END

The report decides which ASINs; the child loop does the acting. keyword, target and adGroup all work this way. Note the placeholder: inside the child loop a bare {asin} would ask the keyword for an ASIN it does not have, so name the outer row, {accumulated_asin.asin}.

Metrics & fields

Read any metric off an item over the loop's window (or an inline one):

Plus settings and identity per entity: bid, bidInherited, budget, state, name, matchType, keywordText, searchTerm, asin, adType, adFormat (the Sponsored Brands format of an ad group, its keywords and its targets: "Store Spotlight", "Product Collection", "Video", "Brand Video", or "Mixed" when one ad group holds ads of several formats; NONE outside Sponsored Brands), targetingType, biddingStrategy, portfolioName, adGroupCount, the owning campaign's campaignName / campaignState (on ad groups, keywords, targets, search terms and ASINs, no relation hop needed), placement percentages (top_of_search, product_pages, rest_of_search), whose own names are placementTopPct / placementProductPagePct / placementRestOfSearchPct, so either spelling reads, and recency fields days_since_bid_change / days_since_budget_change / days_since_placement_change. Friendly aliases work everywhere (daily_budget, purchases, conversion_rate, tos, …), the editor autocompletes them all.

Which kind of target is this? Use target.targeting. It reads exactly one of "close match", "loose match", "substitutes", "complements" (the four Sponsored Products auto-targeting clauses) or "product" for manual product and category targeting, and nothing at all when the row does not say, normal for Sponsored Brands and Display targets. It is what you want for a per-clause rule, such as a lower maximum bid on complements than on close match. target.targetingClause is the same field under its original name and still works.

targetingMode is not that field: it reads "AUTO" or "MANUAL", whether the target sits in an auto or a manual campaign, and never names the clause. target.targetingMode = "SUBSTITUTES" therefore matches nothing, and the editor refuses it rather than letting the rule run to no effect. Any time you mean a clause, write target.targeting.

Has this search term already been negated? searchTerm.negated is TRUE when an exact negative already covers that term in its ad group or campaign, counting both the negatives a sync read back from Amazon (so negatives you or another tool created in the console are seen too) and the ones MerchDash itself applied. It is the gate every negation recipe filters on, and the reason a negation rule doesn't re-propose the same term every run:

Less common fields

Everything above covers most rules. These are real too, and read the same way:

Time ranges

The window after FOR EACH is optional and defaults to the last 30 settled days. Any metric read can carry its own inline window: keyword.clicks IN LAST 7 DAYS.

Conditions & operators

Settings read as they are now. Time ranges apply to metrics only. Fields such as bid, budget, biddingStrategy, state, and the placement percentages always return their current value, an inline window on one (keyword.bid IN LAST 30 DAYS) does not look up what it used to be. To react to a change, use DAYS_SINCE_CHANGE("bid") / LAST_CHANGE("budget"), and DAYS_SINCE_CHANGE("top of search") for a placement.

Placement adjustment cool-downs

A Sponsored Products campaign carries three placement bid adjustments, top of search, product pages, rest of search, and campaign.setPlacementBid() changes them. Because a placement adjustment needs several days of traffic before its effect is visible, a rule that adjusts one should refuse to adjust it again straight away; otherwise the next run judges the same data and moves it a second time.

Ask how long ago it changed the same way you would for a bid or a budget:

The count covers every placement change MerchDash applied, from a rule and from a bulk edit on the Campaigns page alike, and is Infinity for a campaign it has never adjusted, so a first run still matches. Placement recency is campaign-level and Sponsored Products only; on a keyword, target or ad group it reads Infinity. The percentages themselves stay read-only: campaign.placement.top_of_search reads, setPlacementBid() writes.

Audience bid adjustments

A Sponsored Products campaign can carry up to 10 audience bid adjustments, each for one audience, Amazon's own (High interest…, Purchased brand's product, Clicked or added brand's product to cart, High likelihood of purchase) and your Amazon Marketing Cloud audiences. Each is a whole-number percentage, 0–900, on top of the placement adjustments. You see and edit them on the campaign's page, under Placements → Audiences; a rule reads and changes them like this:

Name an audience the way Campaigns shows it. Part of the name is enough when it matches exactly one audience (case and punctuation are ignored); you can also write its audience id. A name that matches nothing, or several audiences, stops the rule and lists the choices, rather than reading 0 or guessing. The audiences a marketplace offers are read from Amazon and refreshed with each sync.

Cool-downs for this rule only

Every cool-down above counts any change MerchDash applied, from this rule, from another rule, from a one-off mass run or a manual edit. That is usually what you want: two rules should not both move the same bid on the same day. But it also means a rule's own DAYS_SINCE_CHANGE("bid") >= 14 is held off by a change it never made.

Add "this rule" as a second argument to count only the changes this rule applied:

“This rule” is the saved rule: editing its script keeps its history, while a copy, an imported shared rule or a rule deleted and created again starts with none. An item the rule has never changed reads Infinity, so a first run still matches, and so does a dry run of a rule you have not saved yet. Only applied changes count, as above, and undoing a run is itself a change, so it restarts the cool-down.

Another rule's changes

Name a different rule instead of "this rule" to count only its changes, for example, hold a keyword off for a week after your nightly bid-down rule touched it, whatever other rules did:

Both work with every field ("budget", a placement) and with LAST_CHANGE(). The name or ID has to be written out in quotes, and it is looked up when the run starts: a name no rule on this account has, a name two rules share, or an ID that is not a rule on this account stops the run with a message saying which, it never quietly reads “never changed”. A rule can name up to 10 other rules.

Changes no cool-down tracks

A one-off or bulk rule, say a mass bid cut, resets every cool-down it touches, so your regular rules hold those items off afterwards. Put this line at the top of the rule to keep its changes out of every cool-down:

Its changes are still reviewed, applied, listed in History and can be undone like any other, they just never count as a “last change”: not for DAYS_SINCE_CHANGE(), daysSinceBidChange / daysSinceBudgetChange, "this rule" or RULE(), and undoing one is not counted either. The line applies to changes made while it is in the script; adding it later does not hide earlier ones. Because such a rule's own changes are never counted, it cannot use "this rule" or the daysSinceRule… fields, the rule is refused when you save it. The account-wide cool-downs still work in it and see every other rule's changes.

A rule's own maximum bid

Every bid a rule writes is held under your maximum bids in Profile → General. A rule can set those aside, or set its own, for its runs only, your profile and every other rule are unchanged. Put the lines at the top of the rule:

• A line sets its level and everything under it. # MAX BID SP 1.50 also replaces a Profile close-match maximum of $0.30 in this rule. What no line names keeps its Profile maximum, # MAX BID SP 1.50 leaves Sponsored Brands as your profile has it.
• The narrower line wins, whatever the order: above, close match is capped at $0.60 and everything else at $1.00.
• Only the rule's caps: write # NO MAX BID as well as the # MAX BID lines.
• Amazon's own limits always apply, per marketplace: in the US $0.02–$1,000, and for Sponsored Brands at least $0.10, or $0.25 for video ads (in Europe €0.10 / €0.15). See bid limits. A bid already above the cap can still come down, but not go up.
• A capped change says where the cap came from in History, “capped at this rule's $1.00 maximum bid (# MAX BID)”.

A # MAX BID line has to end in an amount; one that does not is an ordinary comment. An amount outside $0.02–$1,000, a type the ad product does not have (Sponsored Display has none; Sponsored Brands has KEYWORD and PRODUCT) or the same cap written twice is refused when you save the rule. Manual bulk edits always use your Profile maximum bids.

Entities with no impressions

Amazon only reports a keyword, target or ASIN on days it actually showed, so one with zero impressions in the window has no report row at all. A FOR EACH normally iterates what was reported, which is where its metrics come from, so those silent entities used to be invisible to every rule. On a quiet portfolio that can be most of it.

MerchDash decides this per loop, with no syntax on your part. A silent row reads as zero impressions, clicks, cost, orders and sales (ACOS, ROAS, CTR and CVR are undefined, so every comparison against them is false).

When they are included

First, the condition has to be able to match one at all. keyword.impressions < 1000 can; keyword.clicks > 7 never can, so that loop keeps reading reported rows only and stays exactly as fast as before.

Then it depends on what the rule does:

• setBid and note, always included. Raising the bid on something nobody has seen yet is the entire point.
• pause, archive, enable, setState, addNegative, removeNegative, createKeyword, createTarget, addAsin, only when the rule tests impressions. Write impressions = 0 or impressions < 50 and it reaches them.
• createPortfolio, createCampaign, createAdGroup, never. They create something, so a block that calls one reads reported rows only, even though it is written inside a LET rather than as an action.

The reason for that last rule is that clicks = 0 and orders = 0 describe something that ran and failed, that is how almost every “pause the losers” rule is written. Something that never ran is a different thing, and only an impressions test says so. Without that distinction, a rule meant to pause a handful of duds would pause every idle keyword and ASIN in the account.

FOR EACH product IN LAST 60 DAYS:
  IF product.impressions = 0:            # reaches ASINs that never ran
    product.pause()
END

FOR EACH keyword IN LAST 30 DAYS:
  IF keyword.clicks = 0:                 # only keywords that DID run
    keyword.pause()
END

What is covered

Keywords, targets and ASINs work as described. Campaigns and ad groups have always been read from the full stored list, so one with no traffic already appears with zeros. Search terms cannot be: a search nobody typed does not exist.

Archived entities are never included, whichever rule you write.

Sponsored Brands keywords and targets are included once MerchDash has confirmed them with Amazon. One that has ever had an impression is confirmed straight away; the rest are confirmed during the regular background refresh, so a newly created Sponsored Brands keyword can take a few days to appear. Until it is confirmed it is left out, with or without the comment below.

Forcing it

Override the decision with a comment above the loop, it applies to every FOR EACH below it, until another one overrides it:

# INCLUDE ZERO IMPRESSIONS
FOR EACH keyword IN LAST 30 DAYS:
  IF keyword.campaign.portfolioName = "Winter":
    keyword.setBid(keyword.bid + $0.02)
END

# EXCLUDE ZERO IMPRESSIONS forces the opposite, which is worth doing on a very large account when you only care about entities that actually ran.

Looking things up by name

A rule loops over one kind of item, and every relation points upward, a keyword knows its campaign, but a campaign does not list its keywords. The lookups fill that in: they fetch a specific campaign, ad group or portfolio by name from anywhere in a rule, and read what is inside it.

Three things worth knowing. A lookup that finds nothing answers NONE, so test it with IS NONE / IS NOT NONE, and calling an action on NONE stops the run rather than quietly doing nothing, because a rule with a stale name would otherwise look like a rule that simply had nothing to do. A name matching two items also stops the run and names both IDs: names are not unique on Amazon, so the rule cannot guess which one you meant, use the _ID form. And a lookup inside a loop costs one read no matter how many rows the loop has, so it is safe to write it there.

Paused & archived campaigns

The mirror image of the section above. A campaign you paused part-way through the window still reported for the days before that, so everything inside it, keywords, targets, ad groups, ASINs, search terms, is still in the data a FOR EACH reads. Rewriting bids there costs you part of the run's change limit and can never win an auction.

Skip paused and archived campaigns in Profile → General (on by default) leaves them out. Two kinds of loop keep their paused campaigns automatically, so the setting can't turn a rule into a no-op:

• A loop that can run enable() or setState(), a reactivation rule has to be able to see what is off.
• A loop that reads campaign state itself: campaign.state, keyword.campaignState, target.campaign.state, or the same hop bound to a variable first, LET campaign = keyword.campaign then campaign.state. You have already said what you want.

Archived campaigns are skipped either way, with the setting on, with it off, and for both of the loops above. Amazon rejects every write into an archived campaign, so those rows can only become failures in your history. Turning the setting off brings back paused campaigns, nothing more.

Force it per rule with a comment above the loop, scoped exactly like the zero-impressions directive:

# INCLUDE PAUSED CAMPAIGNS
FOR EACH keyword IN LAST 30 DAYS:
  IF keyword.acos > 45%:                 # prepare bids before relaunching
    keyword.setBid(keyword.bid * 0.9)
END

# EXCLUDE PAUSED CAMPAIGNS forces the skip on, even when the setting is off and even for a loop that would otherwise exempt itself.

Actions

Functions

Building a campaign

A rule can build the whole structure, portfolio, campaign, ad group, ASINs, targets and keywords, in one pass:

The constant names inside the loop are deliberate. However many search terms match, that is one campaign and one ad group: each name is a single request, proposed once and reviewed once, with the ASINs and clauses batched onto one row each.

Sponsored Brands campaigns

Add adType: "brands" to build a Sponsored Brands campaign instead. It takes no targeting: and no strategy:: a Sponsored Brands campaign has no auto or manual split, and its bidding stays at Amazon's default. Its ad groups take no bid either, so put the bid on each keyword:

The ad. A Sponsored Brands campaign serves nothing until it has an ad, and Amazon refuses keywords in a Sponsored Brands ad group until it has one. addVideoAd() puts a video ad in the ad group, built from a video your account already runs, nothing is uploaded, and the ad you took it from is not changed (the new ad has its own metrics). Say which video with one of:

• from: FIND_SB_AD("ad name"), the video and ASIN of that ad.
• asin: "B0ABC12345", the video ad that advertises this ASIN. If the ASIN has several different videos, the rule stops and names them; use from: to pick one.
• video: "cat-mom.mp4", the video by its name in your Amazon Ads asset library (the file name it was uploaded under). The ASIN comes from the ads already running that video; for a video no ad uses yet, add asin: as well. To use a new video, upload it through the API: it is usable under the name you give it as soon as Amazon has processed it (GET /api/v1/videos?refresh=true shows it ready). Videos added in Amazon Ads itself are picked up by sync once a day, so one uploaded there today may need until tomorrow.

name: sets the new ad's name (it defaults to the source ad's) and state: "paused" builds it switched off. Amazon reviews every new Sponsored Brands ad before it serves, usually within a day. Call addVideoAd() before createKeyword(): keywords into the same ad group then wait for the ad. Without an ad, the run that builds the ad group skips its keywords and says so in the run summary, add the ad in Amazon's console, and the rule's next run creates them. If no video ad matches (a wrong name, an ASIN with no video ad, or one Amazon's review rejected), the ad is skipped and the run summary says why.

Product collection, store spotlight and brand video ads. addSbAd(from: FIND_SB_AD("ad name")) copies one your account already runs into the ad group, its brand, logo, headline, products, video and landing page, which a rule could not supply on its own. Change the copy with headline: "…" (at most 50 characters), asins: "B0…, B0…, B0…" (a product collection's one to five products), logo: "logo name" (an image in your Amazon Ads asset library, by its name there) and landingPage: "Home" (a page of your own Amazon Store, by name or URL). name: and state: work as for addVideoAd(), and so does the order: call it before the keywords. A video ad is copied with addVideoAd().

No ad to copy? addSbAd(format: …) builds a product collection or store spotlight ad from parts instead of from: (use one or the other). Both need headline: and logo:. A "product collection" also needs asins: and lands on the product list, or on a store page when you add landingPage:. A "store spotlight" needs landingPage: and pages: "Home, T-Shirts, Mugs", exactly three different pages of your store, each shown with its first product. The brand name is brand: "…" (at most 30 characters), or the one brand your existing Sponsored Brands ads carry. Brand video and video ads cannot be built this way, they are copied.

The goal. goal: chooses what Amazon optimises a Sponsored Brands campaign for: "page visits" (the default, paid per click), "impression share" (top-of-search impressions) or "new customers", those two are paid per 1,000 viewable impressions (vCPM), so the bids on their keywords are per 1,000 impressions, or "ad views". Amazon cannot change a campaign's goal later. Your maximum bid (Profile → General) is a per-click limit, so it does not cap the bids in a per-1,000-impressions campaign; Amazon checks those against its own vCPM range.

Undo. Reverting a run archives the Sponsored Brands campaigns, ad groups and ads it created (archiving is final on Amazon). A campaign or ad group that was already there is never touched.

Fill a Sponsored Brands ad group with createKeyword() for keyword targeting, or with createTarget(PRODUCT_TARGET("B0…"), $0.60) / CATEGORY_TARGET("12345") for product targeting, a Sponsored Brands product-targeting campaign is the same campaign and ad group, filled with targets instead of keywords. One or the other per ad group: Amazon refuses a product target in a Sponsored Brands ad group that has keywords, so a rule that sends both to the same new ad group will not save. Within one run, the kind that reaches an ad group second is skipped and counted in the run summary; an ad group that already holds the other kind from before is refused by Amazon, and History says why. For both, create two ad groups, each with its own addVideoAd(). Give every one a bid: Sponsored Brands ad groups have no default bid, and bids start at its floor ($0.25 for a video ad group in the US, €0.15 in Europe). Targets wait for the ad exactly like keywords, so call addVideoAd() first. addAsin() is Sponsored Products only, and a rule that uses it there will not save.

Two things to know

A rule has to ask. # ALLOW CREATION on a line of its own is what lets a rule build campaigns, ad groups and Sponsored Brands ads; without it the rule will not save. Every other action a rule can take moves a number on something you already chose to run, a new campaign is new spend, so it is the one capability a rule cannot start using because somebody edited it. (createPortfolio does not need it: a portfolio holds no budget.)

Everything is created live. The campaign, the ad group, the ASINs, the clauses and the keywords all arrive ENABLED, so a structure a rule builds serves as soon as you approve the run, there is no second run and nothing left to switch on. To build a piece switched off instead, add state: "paused" to any create verb:

"enabled" and "paused" are the only two values, and each create verb takes its own, a live campaign whose keywords go in paused is a perfectly good thing to ask for. One thing still belongs to a later run: a rule cannot enable, rename or re-budget a campaign on the run that creates it, because there is nothing there yet to change, and those lines are refused when the rule is saved. Everything settable at creation is a named argument instead.

A fuller example