Wire Monitors

Monitor a site that has no public API — run a managed Wire action on a schedule and diff the JSON it returns

A wire monitor (scope: "wire") runs a managed Wire API action on each interval and diffs the JSON it returns. Use it when the thing you want to watch lives behind a login, an anti-bot wall, or a site with no public API of its own — Wire returns clean structured data, and the monitor tracks it for changes.

It reuses the same schedule, alerting (webhook + email), and AI meaningful-change filtering as page and site monitors. The only difference is where the data comes from: instead of scraping a URL, each check submits a Wire task and diffs the returned object.

How it works

Pick a Wire action from the catalogue (e.g. amazon.search_products) and, if it needs auth, a connected identity.
On every check the monitor submits a Wire task with your wireParams and waits for the result.
The returned JSON is stored as a snapshot (as specific_data).
If it differs from the previous result, a change is recorded and any configured alerts fire.

The whole returned object is compared — turn on aiMode to be alerted only on meaningful changes (and get a plain-language summary), optionally narrowed with aiGoal.

Create a wire monitor

Set scope: "wire" and wireActionId on POST /v1/monitors. url is still required — use the Wire site's URL; it's only used for display and as the monitor's title.

{
  "url": "https://www.amazon.com",
  "scope": "wire",
  "wireCatalogSlug": "amazon",
  "wireActionId": "amazon.search_products",
  "wireParams": { "query": "usb-c cable", "country": "US" },
  "intervalMinutes": 720,
  "aiMode": true,
  "aiGoal": "only when a new top result appears or a price changes",
  "alertWebhookUrl": "https://your-app.com/hooks/anakin"
}

Field	Required	Description
`scope`	yes	Must be `"wire"`.
`wireActionId`	yes	The action to run each check, e.g. `amazon.search_products`. Browse actions in the Wire catalogue.
`wireCatalogSlug`	recommended	Catalogue slug of the Wire site the action belongs to, e.g. `amazon`.
`wireCredentialId`	when the action's auth is `required`	The credential id of a connected identity for that site. Actions with auth `none` don't take one; `optional` actions return richer data with one.
`wireParams`	depends on the action	Parameters passed to the action. The shape is defined by the action (each has `name` / `type` / `required`).
`wireWatchPaths`	optional	JSON paths (from the action's result) to diff. Empty = diff the whole payload. See Watch specific fields.

watchMode is forced to specific_data server-side and outputSchema is ignored — the Wire engine already returns structured JSON, so there's nothing to extract. Any maxPages / maxDepth / crawl fields are ignored too.

Auth. On the dashboard you never handle an API key — pick the site, action, params and identity in the Monitor via Wire flow and it's wired to your account automatically. Over the REST API you authenticate with your X-API-Key as usual; the scheduler calls the Wire engine on your behalf using the same account, so the action runs as you (your identities, your credits).

Credits

creditCostPerRun is reported as a nominal 1 on the monitor object. The real cost is the action's own creditsPerCall, billed by the Wire engine per task.
Turning on aiMode adds +1 credit per check for the meaningful-change pass.
A failed Wire task (the action errors or times out) is not billed a monitor credit and does not record a change.

Watch specific fields

By default a wire monitor diffs the whole returned payload. For actions that return volatile or list-shaped data (a search result set, rankings, rotating image URLs), that can flag a change on almost every check. Narrow it with wireWatchPaths — a list of JSON paths into the result; only those are compared.

Each path is dot-separated, with numeric array indices and a * wildcard over arrays:

{
  "url": "https://www.imdb.com",
  "scope": "wire",
  "wireCatalogSlug": "imdb",
  "wireActionId": "im_search",
  "wireParams": { "query": "fast and furious" },
  "wireWatchPaths": ["results.0.id", "results.0.rank", "results.*.title"],
  "intervalMinutes": 720
}

results.0.rank — the top result's rank.
results.*.title — every result's title (as an ordered list).
Omit wireWatchPaths (or send []) to diff the whole payload.

The diff then reports changes keyed by path, and AI meaningful-change (if on) only considers the selected fields. On the dashboard, click Inspect output in the monitor form to run the action once, preview its JSON, and tick the fields to watch.

Non-JSON action output (rare) is always diffed whole; wireWatchPaths is ignored for it.

The change payload

A wire monitor's diffJson is a fields diff whose before / after are the full JSON objects the action returned, and changedFields are the top-level keys that changed. From GET /v1/monitors/:id/changes:

{
  "type": "fields",
  "changedFields": ["results"],
  "before": { "results": [{ "title": "USB-C Cable 3ft", "price": 8.99 }] },
  "after":  { "results": [{ "title": "USB-C Cable 3ft", "price": 6.49 }] },
  "aiMeaningful": [
    { "description": "Top result price dropped", "before": "$8.99", "after": "$6.49" }
  ]
}

The snapshot's extractedData holds the full returned object for each check, so you can pull the raw result history from snapshots. aiMeaningful and summary are present only when aiMode is on.

Limits & notes

Minimum interval: 15 minutes, same as other monitors.
Wire monitors count against your active-monitor cap (Free 5 / Pro 20 / Scale 100).
If the action requires auth and its identity's credential expires, checks fail until you reconnect it in Wire — the monitor keeps trying on schedule.
Manage everything else — pause/resume, run-now, alerts — with the same endpoints as page monitors.

Example

curl -X POST https://api.anakin.io/v1/monitors \
  -H "X-API-Key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.amazon.com",
    "scope": "wire",
    "wireCatalogSlug": "amazon",
    "wireActionId": "amazon.search_products",
    "wireParams": { "query": "usb-c cable" },
    "intervalMinutes": 720,
    "aiMode": true,
    "alertWebhookUrl": "https://your-app.com/hooks/anakin"
  }'

import requests

res = requests.post(
    "https://api.anakin.io/v1/monitors",
    headers={"X-API-Key": "your_api_key"},
    json={
        "url": "https://www.amazon.com",
        "scope": "wire",
        "wireCatalogSlug": "amazon",
        "wireActionId": "amazon.search_products",
        "wireParams": {"query": "usb-c cable"},
        "intervalMinutes": 720,
        "aiMode": True,
        "alertWebhookUrl": "https://your-app.com/hooks/anakin",
    },
)
monitor = res.json()
print("Created wire monitor", monitor["id"])

const res = await fetch("https://api.anakin.io/v1/monitors", {
  method: "POST",
  headers: { "X-API-Key": "your_api_key", "Content-Type": "application/json" },
  body: JSON.stringify({
    url: "https://www.amazon.com",
    scope: "wire",
    wireCatalogSlug: "amazon",
    wireActionId: "amazon.search_products",
    wireParams: { query: "usb-c cable" },
    intervalMinutes: 720,
    aiMode: true,
    alertWebhookUrl: "https://your-app.com/hooks/anakin",
  }),
});
const monitor = await res.json();
console.log("Created wire monitor", monitor.id);