AI workers for Nimble

What is an AI worker for Nimble?

An AI worker for Nimble is an AI agent scoped to one web-research job, such as tracking how a competitor's product page changes, watching what Google and the AI assistants say about your brand, or turning a site into clean text it can answer questions from. It reaches the public web through your connected Nimble account, and the sites it may visit, the pages it may fetch and how much it may spend are all settled before it runs.

What these workers do

Watch the pages that matter

Reads a handful of competitor or supplier pages on a schedule, through Nimble's unblocking network when a site pushes back, and reports what changed in the wording, the pricing or the claims.

Track what Google shows for your queries

Runs the searches your buyers run and returns who ranks, what the AI Overview says and which Maps listings appear, so a shift in the landscape is a report rather than a surprise.

Hear what the AI assistants say about you

Asks ChatGPT, Perplexity, Gemini and Grok the questions your buyers ask and records the answers week on week, including who they recommend instead.

Pull product and listing data into fields

Uses a prebuilt template to return Amazon, Walmart, Target or Best Buy product pages and search results as structured fields, ready to compare without parsing a page.

How an AI worker runs in Nimble

The reach is the open web, so scope is the first question

A prebuilt template counts too. Each one reads a known site, so a worker blocked from TikTok cannot run the TikTok template either.

Reading is cheap, crawling is not, and they are separate switches

You choose what comes back

What Google and the assistants are saying

What web reading is actually for

Nimble questions, answered.

Can a worker visit any site on the internet?

Only the ones you allow. By default a connection reaches the open web minus anything you block, and you can flip it to reach only the sites you name. Either way the check happens before the request is sent, and the same rule covers the prebuilt templates because each one reads a known site.

How do we stop a worker running up a large bill?

Crawling, the one job that bills per page across a whole site, sits behind its own switch and its own page budget, separate from the permission to read. Every other call is one bounded request. Nimble bills your own account directly, so the spend is visible on their side as well.

Does it change anything on the sites it visits?

No. Everything here is reading: search results, pages, Google results, template fields and crawled pages. Nothing is posted, submitted or altered anywhere, and results come back through the same firewall that decided what could be reached.

What about sending our own cookies or clicking through a page?

Those are off until you grant them by name. Forwarding headers or cookies to a site, driving the page with clicks and scrolls, and letting a crawl wander off the path it was pointed at are each a separate capability a worker only gets because someone decided it should.

What AI workers can do in Nimble

The tools a worker can be granted in Nimble once you connect it. A kit grants only the ones its job needs, and you can narrow them further on the worker.

Nimble Search

Search the live web through Nimble and get AI-ready content per result (title, url, description, content). Narrow before you widen: `timeRange` or a `startDate`/`endDate` pair for recency, `includeDomains`/`excludeDomains` to pin sources, `focus` for news / coding / academic / shopping / social / local, `contentType` to find documents (pdf, xlsx, docx, pptx) under the general focus. `searchDepth` 'lite' returns snippets fast and cheap; 'standard' (default) returns rich content. `fullContent` fetches every result's whole page and costs one page fetch per result — leave it off and use nimble_extract on the few that matter. An unsupported narrowing value is rejected naming what IS supported; it is never silently dropped. Results are filtered by this connection's egress (domain/URL allow-block) rules on the way out, so read `accessInfo`: a short list may be scope, not an empty web.

Nimble Search Engine Results

Run a real Google query through Nimble and get the results page as typed entities rather than a web search: `google_search` for organic results, `google_aio` for the page with its AI Overview, `google_news`, `google_images`, `google_maps_search` for places matching a query, `google_maps_place` for one place's details and `google_maps_reviews` for its reviews. Rows that name a URL (organic results, news, places) come back as documents with the raw entity under `structured`; features without a URL (answer box, AI overview, related questions and searches) come back in the response-level `structured` block, unless this connection's egress rules restrict what it may reach, in which case they are withheld and `accessInfo` says so. You send a query and an engine, never a URL. Rows are filtered by this connection's egress rules on the way out — read `accessInfo` before concluding a result was missing.

Nimble Extract Page

Fetch one URL through Nimble's unblocking network and get it back as clean markdown, plus whichever other formats you ask for (`html`, `screenshot`, `headers`). Set `options.render` true for pages that only fill in under JavaScript; `options.country` to fetch as a visitor from that country; `options.parser` (a CSS-selector schema) to pull specific fields into `structured`. The URL is checked against this connection's egress (domain/URL allow-block) rules BEFORE anything is fetched, so a refusal is a rule rather than a broken page. Read `accessInfo`: formats this token cannot see are dropped from the request, so a missing `screenshot` or `html` means the format was removed, not that the page had none.

Nimble Map Site

Discover a site's URLs from one seed URL — each with its title and description — to plan what to extract or crawl. Far cheaper than a crawl: map first, pick the pages you actually want, then nimble_extract them. `sitemap` 'only' trusts the site's sitemap, 'skip' follows links only, 'include' (default) does both; `domainFilter` keeps the list to the exact host, its subdomains, or everything found. The seed URL is checked against this connection's egress rules before the call and every discovered link on the way out; `accessInfo` counts the hidden ones.

Nimble List Templates

List the prebuilt Nimble extraction templates this token may run — Amazon, Walmart, Target and Best Buy product pages and searches, Google search / AI Overview / Maps, what ChatGPT, Perplexity, Gemini and Grok answer to a prompt, TikTok accounts, Facebook pages, YouTube Shorts — each with the site it reads and, when the vendor publishes one, its parameter schema. Call it once to learn a template's `params` before nimble_extract_template. Templates whose site is blocked by this connection's egress rules are not listed; `accessInfo` says how many.

Nimble Run Template

Run one prebuilt Nimble extraction template and get its parsed fields back in `structured`: `amazon_pdp` / `walmart_pdp` / `target_pdp` / `best_buy_pdp` for a product page, `amazon_serp` / `walmart_search` for a store search, `google_search` / `google_search_aio` / `google_maps_search` for Google surfaces, `chatgpt` / `perplexity` / `gemini` / `grok` for what an AI assistant answers to a prompt (brand monitoring), `tiktok_account`, `facebook_page`, `youtube_shorts` for social. `params` are template-specific (ASINs, keywords, a prompt, a handle) — nimble_list_templates shows the schema where the vendor publishes one. The site the template reads is checked against this connection's egress rules before the call, so a refusal is a rule, not a vendor outage. Read `accessInfo`.

Nimble Crawl Site

Start an asynchronous crawl of a site from one seed URL. Returns a `job.id` immediately; poll nimble_get_job for progress and read pages with nimble_read_job_page once some have completed. Every delivered page is billed, so size it deliberately: `limit` (clamped to this token's per-job cap, then to 10,000), `maxDiscoveryDepth`, `includePaths`/`excludePaths` regexes, and `sitemap` 'only' for a sitemap-driven walk. `extractOptions` shape each page like nimble_extract. The crawl needs this connection's egress rules to allow the WHOLE host — a token allowed only some paths of a site cannot crawl it (map and extract those paths instead). Read `accessInfo` on the launch: it reports the clamped page limit and anything stripped.

Nimble List Jobs

List the crawls this token started, newest first, each with its `id`, seed URL and status. Use it to recover a job id you did not keep, then poll it with nimble_get_job and read pages with nimble_read_job_page. Jobs started by anyone else are never listed, so an empty list means this token launched nothing, not that the account is idle.

Nimble Get Job

Poll one crawl by the `jobId` its launch returned. Gives `status.status` ('queued' or 'running' while it works, then 'completed', 'failed' or 'cancelled') and the page counters `total` / `pending` / `completed` / `failed`. Pages themselves are not in this response — read them with nimble_read_job_page as soon as `completed` is above zero, you do not have to wait for the whole crawl. Only jobs this token started are readable and an unknown id is reported as not found.

Read Crawl Result Page

Read one bounded window of a crawl's completed pages: up to `limit` pages starting at `offset`, each as a document in the formats the crawl was launched with. `sourceReadInfo` carries read state, coverage and `nextArgs` for the next window — call the same tool again with them until `hasMore` is false. Pages still landing are not failures; a pending crawl simply has more to come. Current egress and field grants apply on every page, and `accessInfo` counts anything hidden.

Nimble Cancel Job

Cancel a running crawl by `jobId` so it stops consuming credits — worth doing as soon as a crawl is clearly going wider than intended. Pages already delivered stay readable with nimble_read_job_page, but pages not yet fetched are abandoned and a cancelled crawl cannot be resumed; start a narrower one instead. Only jobs this token started can be cancelled, and an unknown id is reported as not found.