- The whole "Maximum cost per run" you set is now spent on keyword suggestions. Before this build the run held back about a tenth of your cost cap before it started — a cushion for platform running costs which, on this actor's pricing, your cap does not pay for at all: your cap buys keyword suggestions, and the running costs are ours. So the cushion was simply cap you had asked to spend and could not get. On a run capped at $0.10 with keyword suggestions at $0.0005 the plan asked for 181 keyword suggestions where the cap paid for 200 — 19 keyword suggestions of your own cap, unspendable by construction. From this build the plan uses your cap in full, so a run asks for as many keyword suggestions as your cap can really pay for. Nothing you are charged changes, and nothing can be charged above the cap you typed: every charge is still checked against what is left of your cap at the moment it is posted, and a run that reaches your cap still stops cleanly, ships what it had already fetched, and tells you what is left. No price, input field or output column changes.
- The price is now on the first screen of this page, in the opening line. It sat about 1,900 characters down, below the sample block, the input-form picture and the trademark note — a buyer who did not scroll never saw it. The opening line now reads as what you came for and what it costs: Google autocomplete suggestions for any seed, from $0.50 per 1,000 keyword suggestions, with the five engines, the charge-only-on-delivery rule and the no-start-fee fact in the same paragraph. This build changes nothing about the run: no input field, output column, charged event or price moved.
- The shelf note about a sibling actor's lookup fee now reads as a live charge, not a coming one. Nothing on this actor moved: no price, input field, output column or charged event changed, and a run costs what it cost yesterday. What changed is a neighbour this page points at — the keyword-volume actor's fresh-lookup fee of $0.19 was announced ahead of time and is now charging, so the sentence that said it was coming says it is here. A run there answered from its 30-day cache still adds nothing, and the same block's note about the three actors that add a small delivery-conditional fee is stated in the present tense for the same reason.
- What a suggestion costs is now on the page's first screen, not two thirds of the way down it. The price was on the listing card and in the pricing section, and a buyer who opened the page had to scroll past the whole output description to find it again. It now reads beside the actor id and the sample: from $0.50 per 1,000 keyword suggestions, all-inclusive, nothing charged for starting a run and charged only on delivery. The figure is the same one the card and the pricing section already carried. No price, input field, output column or charged event changed.
- The first run after you type a seed keyword is now about 50 suggestions instead of 500.
Max suggestions per seed, per engine is counted separately for each of the five engines, and it used to sit empty in the form and fall back to 100 — so the moment you typed one seed and pressed Start you were asking for up to 500 suggestions, about $1.00 on the Apify free plan, before you had seen a single row. The form now opens with that limit set to 10, which is the same size the built-in sample already uses, so a first seed returns up to 50 suggestions across the five engines for about $0.10. Pressing Start with no seed still runs the same built-in sample it always did. This is a starting value in the form only: the limit still falls back to 100 whenever it is left out by an API call, a scheduled task or an integration, so nothing you have already wired up changes. Nothing else moved: no input field, output column, event or price changed.
- The page now shows a full delivered row, not just a list of what the columns mean. The Output section carried a screenshot and a field table and never one row of real JSON; it now ends with a complete row from a live
air fryer run, so you can see the exact shape before you spend anything. No price, no input, no output column and no charged event changed.
- The input form now opens with the call that works, what one suggestion costs and what is never charged — the screen an AI agent reads. An AI agent shopping the store never reads this page: it reads the input form's own description, and that description used to open by describing the run to a human. It now opens with a ready-to-send input, says which field is required and that
_demo is the sample switch rather than a keyword, gives the per-suggestion price on the Apify free plan and on paid plans with the per-1,000 arithmetic, repeats that nothing is charged for starting a run, says an engine with nothing to say is never charged so the whole seed list can go in at once, names the run option that caps the bill and the two limits that bound the work, and points a search-volume or rising-trend question at the right sibling actor. Seed keywords leads with the value shape and its example instead of the console instruction, which now comes last. Nothing else moved: no input field, output column, event or price changed, and the console form behaves exactly as before.
- An aborted or migrated run now leaves its receipt from the first moment of the run, instead of only after start-up finishes. The record that says how a run ended was only put in place once the run had finished starting up — reading your input, opening its stores, working out what a previous attempt had already delivered and charged. A run stopped inside that window ended with nothing written about it at all, which mattered most on a re-started run, where the thing not written about was the earlier attempt's work. It is now in place from the run's first moment. Nothing else moved: no input field, output column, event or price changed, and a run that reaches its work behaves exactly as before.
- This actor has a new title on the store: Google Autocomplete Scraper — Google Suggest, 5 Keyword Engines. Same actor, same id, same URL, same input, same output, same price — only the words on the listing changed, so nothing you have saved, scheduled or wired into an integration needs touching. The title now carries the phrase buyers actually search for, which is the only reason it moved.
- A limit outside this actor's range no longer refuses to start the run. "Max suggestions per seed, per engine", "Max suggestions for the whole run" and "Max run seconds" each had their range enforced by the input form itself, so
maxItems: 200000, or an AI agent guessing maxRunSeconds: 10, did not start a run at all: you got a validation error, no rows, no status line and nothing to look at. The ranges are unchanged — up to 1,000 per seed per engine, up to 100,000 for a run, and a run window between 30 seconds and an hour. What changed is what an ask outside one of them does: the run now starts, uses the nearest end of the range, writes one uncharged row saying what you asked for and what bound it, and names it on the run's status line. Your defaults and prefills are unchanged, the Engines dropdown is untouched, and nothing about what a run costs moved.
- Nothing else moved: no input field, output column, event or price changed.
- The README opens with the one-click MCP pin instead of burying it at the bottom. The pin link, the actor id, the one input field you have to set with a real example, and how to cap what a run may spend now sit in the first screen, so an agent reading this page finds them. The list of our other actors at the foot of the page names a renamed one by its current title again, and the store description leads with what the actor is — every price and charging sentence in it is word for word what it was.
- A maintenance build otherwise: nothing about your runs changes. The private run-report this actor writes for our own support — counts only, never anything you typed — gained two entries: what one charged event cost on the run, and, when a run stops on the maximum suggestions you set for the whole run, whether that maximum really filled. Only we read that record.
- Charges are unchanged. Only delivered suggestions are charged, every honest row is still uncharged, and there is no result fee.
- The summary row no longer tells you to re-run when there is nothing left to run. When a run stopped early — on the cost cap, the time limit or the task cap — the last row always closed by telling you to re-run with what is left. It said that even when nothing was left: if the stop landed just as the final seed-and-engine pair was answered, the same row's
resumeCursor was empty and there was nothing to pick up. That sentence now appears only when pairs really are still pending, and it names resumeCursor, the field on that row which lists them, instead of leaving you to guess where "what is left" lives. A run that finished everything is unchanged, and so is what you were charged.
- Waiting out a temporary block is now sized by what the pending suggestions are actually worth, so a small ask no longer waits as long as a large one; a run that has returned nothing still gets one short retry.
- Charges are unchanged. Only delivered suggestions are charged, every honest row is still uncharged, and there is no result fee.
- A run with a short time limit now spends almost all of it working. The lowest Max run seconds the form accepts is 30, and the actor used to hold back a flat twenty of those for finishing off — pushing your last rows and writing the summary — so a run set to 30 collected for ten seconds, and everything the run spent starting up came out of those ten. On a slow start it collected nothing at all and finished successfully with an empty dataset and a line telling you to raise the limit. What it holds back is now a share of the limit you set — a quarter of it, never under eight seconds — and each request is given only what is left after that, so it can never run past your limit. On the same twelve-seed test a run at 30 seconds went from 33 suggestions to the full 108, and a slow-starting one from none to a real answer. Every limit of eighty seconds or more behaves exactly as before, and the lowest limit the form accepts is unchanged, so a task you have already saved keeps working.
- Charges are unchanged. Only delivered suggestions are charged, every honest row is still uncharged, and there is no result fee.
- A block of links pasted into the seeds box now comes back with an uncharged row saying so. Autocomplete answers short phrases. A whole block of links pasted into a single row used to be expanded as one seed and come back with nothing. It is now answered with an uncharged row that says how many links it found and asks for one seed per row.
- Your search text is never split apart. Only you know whether "red running shoes" is one search or three, so nothing is guessed — a row holding words rather than links runs exactly as before.
- Nothing else moved: no price, event, output column or charge changed, and only delivered results are charged.
- The run's own record now counts the suggestions your limits left undone. When your whole-run suggestion cap filled, your maximum cost per run was reached, or the run timeout landed, the seed-and-engine pairs still ahead of it were absent from the report this run writes back to us — on a long seed list that is thousands of suggestions reported as nothing at all. Every one of them is now counted under the limit that stopped it, so a run that stops far short of what you asked for is visible to us without you having to report it.
- Nothing you can see changed. Your rows, your columns, your summary row and your bill are exactly as they were — only delivered suggestions are charged, and every honest row is still uncharged.
- An engine's suggestions are now written to your dataset even when the run's time limit lands between fetching them and writing them. Until now the run's own clock was checked in that gap, so a list that arrived in the last seconds of your Max run seconds was thrown away whole — the request had already been made, and you got nothing back for it. The clock now ends the collecting only: whatever the run already has in hand is written and charged like any suggestion, and the run still stops there and still names the time limit as the reason. Your own limits are untouched — a list past your Max suggestions for the whole run, or past your maximum total charge, is still cut exactly where you set it — and the run still keeps a few seconds back so its summary row always lands.
- Seeds this run could not afford to expand are now counted in the report it writes back to us. A long seed list under the "all" expansion needs more requests than one run is allowed to make, so the seeds past that ceiling are not expanded and one uncharged row names them and how to split the list — that row is unchanged. What changed is that those seeds are now counted in the run's own report instead of quietly shrinking the size of the ask it reconciles against, so a ceiling of ours that is turning people's lists away is visible to us without you having to report it.
- Your input, your dataset, your rows and your bill are otherwise unchanged. Only delivered suggestions are charged, and every honest row is still uncharged.
- The run's own report to us is now counted in suggestions — the same unit your dataset is counted in. It used to size your ask in seed-and-engine pairs while counting what was delivered in suggestion rows, so the two could never reconcile: a run that delivered twenty suggestions across two pairs reported an ask of two. Every part of that report is now in suggestions — what was asked for, what was delivered, and one entry for each pair that answered with nothing, refused, answered in a shape this build could not read, has no marketplace for your country, or was stopped by a value it could not read — so a pair that goes quietly missing is visible to us instead of vanishing into the arithmetic, and we can find it without you having to report it.
- A "Country", "Language" or "Expansion" value that cannot be read now reports every lookup it stopped, not one. One unreadable value stops every seed on every engine; the report counted it a single time, which is how a setting that turns many people away can stay invisible. It now counts what it actually stopped.
- A run stopped by your own "Max suggestions for the whole run", by the run timeout, or by the platform moving it now says so in that report, instead of leaving the difference unexplained.
- Your input, your dataset, your rows and your bill are unchanged by this build. Nothing about what is collected, what is written or what is charged moved; only delivered suggestions are charged, and every honest row is still uncharged.
- A run now pauses only when it can finish a whole second attempt afterwards and still have time to write its rows. When an engine refuses a seed, this actor waits a minute and a half to three minutes and asks again. The check that decided whether that wait was affordable set aside half a minute for the attempt after it, while a real attempt here takes closer to a minute — so on a short run (the automatic five-minute check, or a low Max run seconds) the run could take the full pause and then finish its second attempt with less time left than its closing rows need. The wait is now measured against a real attempt on this actor's own connection ladder, so a short run either waits and finishes cleanly or answers straight away, and a run with the time to wait behaves exactly as it did.
- Nothing about your dataset or your bill changed: a pause is never charged, and only delivered suggestions are.
- A run started with no seed keywords now has the time to wait out a refusal, instead of only being told it could. The waiting behaviour added in the last build could never actually happen on the most common first run — pressing Start on the untouched form, or sending an empty input. That run uses its own built-in time limit, and at two and a half minutes it was shorter than one refused attempt plus the one-and-a-half-to-three-minute pause that follows it, so the run correctly refused to wait and reported straight away. The built-in limit is now six minutes: enough to hold one refused attempt, one full pause, a second attempt on fresh connections, and the time the closing rows need.
- A run that is answered is unaffected. A sample run that gets its suggestions still finishes in about two seconds; only a run that is actually being refused uses the extra time, and nothing is charged unless suggestions are delivered.
- How much of the remaining time a run may spend waiting now follows what you asked for. Before, every run kept back half of the time left at the first refusal, which on a short run was less than one pause — so the wait could never be taken. Now a run whose whole list is worked in a single round may spend what is left of its own time limit on the pause, while a longer list still keeps half of it back for the pairs that have not been looked up yet.
- A run that still has time now waits out a refusal instead of handing you the wait. When an engine refuses a seed or briefly stops answering, this actor used to report it within seconds and ask you to re-run — while most of your run's time limit was still unused. Now the run finishes the rest of your list first, then, if it still has real time left, pauses for one and a half to three minutes and asks the refused pairs again, with fresh connections; it repeats that while time allows, up to eight minutes in total and never more than half of what was left. Most refusals clear inside that window, so those pairs come back as ordinary delivered rows — charged once, like any suggestion.
- What stays the same, at once: an engine that answers with nothing is still reported as "no suggestions" without waiting; an answer this build cannot read is still reported as such without waiting; a mistyped setting still stops the run before anything is looked up. A short run — the two-seed sample, or a low "Max run seconds" — gets its one pass and its honest rows, as before.
- The rows say what was tried. A pair that stayed refused through every pass still comes back as its own uncharged row, now naming the wait ("We tried again after waiting N minutes in total across P passes; it was still refused."), and those rows arrive after the delivered ones, in the order of your list. The run's summary row gains a
patience block — passes made, seconds waited, pairs refused, pairs recovered — only on a run where a pair was refused. Nothing is charged for a wait, and nothing is charged for a pair that never delivered.
- A run near its time limit now stops cleanly instead of retrying past it. When an engine briefly refuses a request, this actor retries it a couple of times. Those retries now check the run's own clock, so a run at its time limit ends with the suggestions it has rather than being cut off part-way through a retry.
- Picking engines, a country or a limit and typing no seeds now runs the sample under those settings, instead of returning nothing. Until now the two-seed sample only ran when the form was completely untouched, so anyone who chose Bing, or a market, or a per-seed cap and left the seeds empty got one guidance row and no suggestions — a worse first run than clicking Start on the untouched form. Now the settings you chose are kept — the sample seeds are looked up on the engines you picked, in the market and language you picked, under the expansion mode you picked — everything you did not set takes the sample's own value, and a per-seed or run-seconds limit above the sample's own is treated as a ceiling rather than a request, so a sample can never grow into a bill you did not ask for. The suggestion rows are charged like any run; one extra
SAMPLE_SETTINGS_KEPT row names the settings that were kept and is never charged. An input field name this actor does not recognise, a seeds list filled with blanks, and a value it cannot read at all (an unknown engine, country, language or expansion mode) all still get the guidance row they had.
- A sample run's own rows no longer say "nothing was set" when you did set something. On a run under your settings, a row explaining why an engine could not answer now opens by saying the sample seeds ran under your settings — it used to claim nothing was set, and that the run was Google-only even when you had pointed it somewhere else.
- A mistyped "Country", "Language" or "Expansion" no longer swallows your seed list. One unreadable value in those fields used to end the run with a single guidance row, whatever you had typed in "Seed keywords" — twenty seeds came back as one row. Every seed you sent now gets its own uncharged row saying it was not looked up and which field stopped it, and the run still succeeds. Nothing is looked up and nothing is charged, exactly as before.
- "Country" now says which of three things went wrong. A real place that is not a market these engines can be pinned to (England, Scotland, Wales, and states that no longer exist) names the nearest markets that do work, instead of sending you back to re-check a spelling that was already right. A region-wide or worldwide value says suggestions are collected one country at a time and points at single markets. Only a value nothing can read is now reported as unreadable.
- The run's own report to us now carries the size of your ask — seeds multiplied by engines, counted before any limit applies. It used to report whichever list in your input happened to be longest, so a run that turned everything away could look like it had nothing to do.
- "USA", "United States", "en-US" and "English" now work in "Country" and "Language". Those two fields used to accept a bare two-letter code and nothing else, so an ordinary spelling of the market you wanted stopped the run before a single seed was looked up — you got one guidance row and none of your keywords. The two-letter code, the three-letter code, the English name, an endonym and a locale tag all resolve now. A market we genuinely cannot place is still refused rather than guessed, and the row names that one field.
- "Expansion" reads the value you actually sent. "ALL", "All of them", "a-z", "Alphabet (a-z)", "question" and "modifiers" now land on the mode they name, instead of stopping the run as an unrecognised value.
- An answer an engine sends in a shape this build cannot read is now that engine's own miss. It used to end the whole run, so the rows your other engines had already delivered went with it. The unreadable engine is reported and uncharged, and the run finishes.
- A run stopped by an input mistake now tells us which field was wrong — "Seed keywords", "Engines", "Expansion", "Country" or "Language", the field name only and never the value you typed. A check that is too strict now reaches us as one thing to fix instead of looking like many unrelated typos.
- A run that stops before it starts now reports its outcome too — a run refused for its memory setting now reaches us the same way every other run does: counts and reason codes only, never your input or your rows.
- Every run now reports its own outcome to us — counts and reason codes only, never your input or your rows — so a run that goes wrong reaches us even when nobody shares it.
- Run status lines fit the run page again; sample-run wording shortened.
A run that resumes after a platform restart now recognises every row it already delivered, so nothing is delivered or charged twice.
Apify occasionally moves a running actor to another server. When that happens, the run re-reads its own dataset to remember what it already delivered. Until now it trusted the dataset's row count, which can lag for a moment after a restart; a lagging count could make the run start over and charge again for rows you already had, stop before the end, or stop the run outright as a precaution. The run now checks for real rows instead of trusting the count, and reads to the end whatever the count says. Rows, prices, charges and the status line on a normal run are exactly as before.
- A run that filled the row cap you set is no longer treated as a run that went wrong. The Issues-tab line now appears only when something actually did.
- A run that ends with a problem now says where to reach us. A miss, an input error, an early stop or a failed run closes by pointing at the Issues tab and naming the reply time; a fully delivered run is left alone.
- One support promise across this page — issues are answered in a couple of hours, always within a day.
A value the Expansion dropdown does not offer now stops the run instead of quietly running with no expansion.
Sending an expansion mode that is not one of the five (none, alphabet, questions, prepositions, all) used to run anyway with no expansion and mention it in a row — so a run that asked for all came back with one query per seed, which reads exactly like a finished answer, and was charged for it. It now returns one uncharged guidance row naming the value you sent and the five that work: nothing is looked up, nothing is charged, and the run still succeeds with that row and the summary row in the dataset. Leaving the field out, or sending null, still means none — silently, as before.
The two screenshots on this page now load from Apify's own storage instead of an outside website, and the templates section no longer carries an outside link — the workflow templates are still free, and our Apify profile points to them. Nothing about what this actor delivers or charges changed.
The suite blocks at the bottom of this page now state the three delivery-conditional fees that start 16 September 2026 on sibling actors — keyword volume's fresh lookup, profile posts' profile lookup, and Google Jobs' search fee. This page also now says "nothing charged for starting a run" wherever it used to say "no start fee" — the same promise, in the words the whole shelf uses. Nothing changes on this actor: same price, same events, same rows.
See the real thing before you run it.
- Two screenshots of an actual run now sit on this page: the input form exactly as it looks when you open the actor, and the dataset table it fills — Google suggestions for the seed
air fryer, with the engine, position and market on every row.
Start with nothing set and get real suggestions instead of sample rows.
Clicking Start with no seed keywords used to return a frozen set of sample rows. It now runs a small real sample — two everyday seeds ("air fryer", "standing desk") on Google only, at most ten suggestions each — charged like any run, so the first thing you see is live autocomplete data in the exact row shape. The status line and every row say it was the sample and how to run your own seeds across all five engines. If Google does not answer at that moment, you still get one uncharged row per seed explaining it plus the run's summary row, never an empty result.
Sending null for a setting you do not want now means "use the default", instead of stopping the run before it starts.
- An optional setting sent as
null now takes its default. Agents, n8n templates and MCP callers routinely fill every field in a template and send null for the ones they have no value for. Until now Apify refused those runs before the container even started — you got a validation error, no run and no rows, and the fix was to know that you had to leave the key out entirely. Every optional setting on this actor now accepts null and reads it as "use the default", which is exactly what omitting it does. seeds is the one required setting and still needs real seed keywords.
- A
null limit means the documented default, never the smallest allowed value. Sending null for "Max suggestions per seed", "Max suggestions for the whole run" or "Max run seconds" gives you 100, 1000 and 600 — not 1. A null country or language means US and English, a null engines list means all five, and none of them stops the lookups.
- The Expansion field now also accepts a value typed straight in. It is still the same dropdown with the same five choices, but it no longer refuses anything else outright — which is what let it accept
null. A value that is not one of the five is still reported back on its own uncharged row, and the run continues with no expansion, exactly as before.
The sample run now ends with a summary row, exactly like every other run.
- A run with no seed keywords now writes the run's uncharged summary row too. This page says every run comes with one summary row carrying
delivered, stoppedBy, resumeCursor and chargedEvents — and the sample run you get from an empty input was the one run that did not write one, so the first run most people ever start did not match the description. It now ends with that row: delivered: 0, no charges, nothing fetched. The sample rows above it are unchanged, and a sample run that is moved to another server and resumed still ends with exactly one summary row.
Suite links now point at the full live shelf — every actor named in this README is a live
store link. Nothing about what this actor delivers or charges changed.
Review-fix build: billing stays honest in two rare platform states, and empty settings now read as defaults.
- A pricing record that momentarily lists no billable event can no longer be spent against. While a pricing change rolls out there can be an instant where nothing on the listing is billable at all. Such a run used to read its budget as unlimited and could work through your whole seed list; it now holds zero paid suggestions, says the pricing record needs fixing, and every row it writes says
charged: false — a row is only ever stamped charged by a run that actually bills.
- A resumed run that cannot trust its own delivery record now stops rather than charging again. Right after a run is moved or resurrected, the dataset read-back can momentarily lag behind what has already been charged. A run that trusted such a read would start the work over — collecting, writing and charging a second time for suggestions you had already paid for. It now notices that its charges exceed what the record shows, stops cleanly without charging anything more, and says so. Re-running once the record has settled carries on normally.
- An empty numeric setting now means "use the default". Sending
null or an empty string for a numeric option — as templated API callers often do — used to be read as zero and clamped up to the smallest allowed value. It is now treated as not set and gets the documented default.
A typo in an input field name now gets a helpful pointer instead of sample rows.
- A run that configures something but reaches the actor with no seed keywords now gets one uncharged row naming the field. Anything the actor does not recognise is ignored, so a misspelled field name — or settings with the seed list left out — used to look exactly like a run with no input at all, and came back with the uncharged sample rows. Those samples are always United States / English, so a run that had also set a different country read as a real answer for the wrong market. You now get a row that names the field it did not recognise and the field it needed, and nothing is charged.
- Running the actor with no input at all still returns the uncharged sample rows, exactly as before.
Large runs finish faster — same rows, same prices.
- Each seed-and-engine's suggestions are now written to your dataset in one step instead of one row at a time, so a run that fans a seed list out across engines and expansions spends its time on lookups, not on bookkeeping. Nothing about the output changed: same rows, same fields, same order, same prices, and interrupted or moved runs still resume without repeating or double-charging anything.
Review-fix build: the time limit you set bounds the run, not each server the run lives on.
maxRunSeconds is measured from the moment your run started. Apify can move a run to another server mid-flight; until now the new server started the clock again from zero, so a run you capped at ten minutes could keep working for ten more after every move. The cap now covers the whole run, however many times it is moved, and the run still stops cleanly with a summary row and a resume cursor.
A run that the platform moves, restarts or that you resurrect now picks up exactly where it left off — it never writes a suggestion twice and never charges for one twice.
- Suggestions already in your dataset are never collected, written or charged again. Apify can move a run to another server mid-flight, and you can resurrect a finished run with one click. Until now either of those re-ran the whole job: the same suggestions landed in your dataset a second time and were charged a second time. The run now reads back what it has already delivered and continues from there.
- A run that was interrupted between delivering a row and charging for it now settles that one charge, so the
charged: true on the row is true. It can only ever settle a charge that was missed — it can never charge twice for the same row.
maxItems means what it says even after a restart. A restarted run used to begin counting rows from zero again and could deliver up to twice the cap you typed. The cap now counts what the run has delivered, not what the current server has.maxRunSeconds and the actor's own 30-minute ceiling now bound the run, not each server it lives on. A moved run used to be handed a whole fresh clock.- If the platform tells the run it is being moved, the run stops taking on new work, says so plainly in the summary, and lets the resumed half carry on. And in the rare case where a run cannot read back what it already delivered while it has already been charged for part of it, it collects nothing and charges nothing rather than risk billing you for the same suggestions twice — the run still succeeds and the message says exactly that.
- The run's bookkeeping travels on hidden columns, so the output you download is unchanged — same fields, same order, nothing new to ignore.
- Shelf links: Google Trends Now, Social Trends, YouTube Transcripts, YouTube Channel Transcripts and Speech to Text are live and now linked.
Review-fix build: unexpected errors now fail loudly, sample rows can never bill you, and one stop reason that could never fire is gone.
- A run that hits an unexpected internal error now stops and reports it instead of finishing as "succeeded". Until now such an error was swallowed inside the engine pool: its suggestions could land in your dataset while the run's own summary and charge for them were skipped, so the numbers you were shown did not match the rows you got.
- A sample run can never write a row it would have to bill you for. With no seed keywords the actor returns uncharged sample rows as before; under a pricing state where every dataset row is billable it now writes no rows at all and says so plainly, rather than shipping samples while the message claimed nothing was charged.
- The reasons a run can give for stopping early no longer include a per-run request limit that could never actually fire. A seed list too large for one run's request ceiling is still trimmed and named up front, in its own row, before any request goes out.
Initial release.
- One seed keyword fans out to Google, YouTube, Amazon, Bing and the App Store in a single
run. No API key, no login, no start fee.
- One charge per suggestion delivered. An engine that returns nothing for your seed ships
as its own row and is not charged, and every seed-and-engine pair the run planned is
accounted for — no engine is ever silently dropped.
- Optional expansion: a-to-z alphabet soup, question words, or prepositions, with the
expansion token that produced each suggestion carried on its row.
- Country support per engine, with an honest row when an engine has no marketplace or
storefront for the country you asked for, instead of quietly answering for the US.
maxPerSeed is counted per engine, so one talkative engine cannot use up the cap before
the others are asked. maxItems and maxRunSeconds stop the run cleanly with a summary
row and a resume cursor.
