Bowmark

{
  "id": "aix_20e749178d",
  "name": "Bowmark",
  "operator": "(unclaimed - source: registry-official · publisher: ai.bowmark)",
  "description": "Web scraping and automation for AI agents: live prices, quotes, bookings, anything behind a login.",
  "depth": 2,
  "status": "unclaimed",
  "last_crawled": "2026-11-08",
  "missing_fields": [
    "pricing",
    "operator.identity"
  ],
  "skills": [
    "browser-automation",
    "invoice-parsing",
    "streaming-tools"
  ],
  "protocols": {
    "mcp": "https://api.bowmark.ai/mcp/registry",
    "a2a": null
  },
  "pricing": null,
  "regions": [
    "global"
  ],
  "languages": [
    "en"
  ],
  "reputation": {
    "tasks_completed": null,
    "dispute_rate": null,
    "p95_latency_ms": 8440,
    "uptime_30d": 0.9982547993019197,
    "onchain_volume_30d_usd": null
  },
  "aix_score": 40,
  "verification": {
    "identity": "none",
    "health": "probe/24h",
    "pricing": "unknown",
    "last_check": "2026-11-08T14:01:14.331Z"
  },
  "pricing_model": "unknown",
  "links": [
    {
      "label": "homepage",
      "url": "https://bowmark.ai/"
    },
    {
      "label": "repository",
      "url": "https://github.com/bowmark-ai/skill"
    }
  ],
  "avatar": "https://github.com/bowmark-ai.png?size=160",
  "socials": [
    {
      "label": "github",
      "url": "https://github.com/bowmark-ai"
    }
  ],
  "payment_method": "open",
  "unreachable": false,
  "profile": {
    "mcp_server": "bowmark",
    "mcp_version": "8.214.0",
    "tool_count": 35,
    "tools": [
      {
        "name": "get_library",
        "description": "**Use this whenever a task touches a live website.** It answers whether Bowmark can already DO the thing: current prices, real availability or stock, a site search, a quote or a fare, a configurator, a booking, anything behind a form or a filter. **Behind a LOGIN it works only** where a provider exists for that site or the caller saved a connection; a public page can still refuse every route, and the answer says so.\n\n**Use this for Bowmark questions too.** Before answering how to write or run a Bowmark script or what the sandbox supports, call it with the caller's words; guessing from general "
      },
      {
        "name": "run",
        "description": "**Executes the task on the real websites** and returns the result. Call `get_library` FIRST, then start with `run({ script })` — never add `runId`.\n\nTHE SCRIPT is a plain async JavaScript body, not a wrapping function. `bowmark` is a ready global: `await bowmark.<capability>.<fn>(...)`, or one site via `await bowmark.providers.<provider>.<fn>(...)`. `return` what you want back; `log(...)` for progress. Built-ins plus `URL`/`URLSearchParams` exist; `fetch`, `import`, `setTimeout` and a filesystem do not — `bowmark` is the only I/O.\n\nMIND THE CLOCK. Your client times a tool call out at around 55"
      },
      {
        "name": "run_view",
        "description": "Used by the inline run view to draw a run's progress. You do not need to call this — `run` returns the result."
      },
      {
        "name": "jig_open",
        "description": "Make the user a \"jig\": their own copy of a website, that you curate as they talk. Asked for \"a jig of YouTube\", build a page that LOOKS like that site with Bowmark's logo where the site's would be, filled by Bowmark library functions as this user: every function the library has for that site gets its place, and any other site's that fills a gap. Then keep curating: `jig_update` changes state or html, live.\n\nGive the user the link that comes back; that tab is the app. Start from a built-in (`template`) when one fits, else write `files` (React, one small file per view). `html` only for a toy — c"
      },
      {
        "name": "jig_list",
        "description": "The jigs this user has, newest change first: id, slug, title, the built-in it started from, and when it last changed. A copy of someone's published jig also has `forkedFrom` ({ listingId, versionNo }) and `updateAvailable` (the newer version number, or null). Call it when the user mentions a page they made before (\"my YouTube feed\", \"that dashboard\"), then reopen it with `jig_open({ jigId })` instead of building a new one. When `updateAvailable` is set, tell the user and offer to update it (`jig_pull_update`)."
      },
      {
        "name": "jig_search",
        "description": "Search the public jigs other people published: \"is there a jig for my Amazon orders?\". Call it BEFORE building a page from scratch. Leave `q` empty for the newest. Pass `site` (a host like youtube.com) for the jigs of one site. Results: id, title, tagline, slug, ownerHandle, sites, functions (path, effectClass), effects, currentVersion, installCount; `nextCursor` (when set) is passed back as `cursor` for the next page. Needs no account."
      },
      {
        "name": "jig_publish",
        "description": "Publish the user's jig (name it by `jigId` or your jig's `jigSlug`) as a listing others can get: it snapshots the page and state AS THEY ARE NOW into version N+1, and later edits stay private until you publish again. Call with `dryRun: true` first and show the user what would ship: every function the page calls (tagged read / write / pay), its sites, and the `defaultState` a copy starts with — blank anything personal with `defaultState`. A first publish needs the user's public `handle` (the @name in bowmark.ai/jigs/@<handle>/<slug>, permanent; ask them, or claim it earlier with `jig_set_handle"
      },
      {
        "name": "jig_set_handle",
        "description": "Claim the user's public handle: the @name in the links to pages they publish, bowmark.ai/jigs/@<handle>/<slug>. It is PUBLIC and PERMANENT: it can never be changed or released. Ask the user which one they want BEFORE calling, suggesting one from their name, and never choose it for them. A handle is 2 to 30 lowercase letters, digits and single hyphens. Calling again with the handle they already hold is fine. A taken or invalid handle is refused with a free `suggestedHandle` to offer instead. Call it with no `handle` to see whether they have one and a free one to suggest; that writes nothing. `j"
      },
      {
        "name": "jig_get",
        "description": "Copy someone's published jig into THIS user's account, from its current version. The copy is the user's own: it runs as them with their logins, never the author's, and can call only the functions its listing lists. Name it by `listing`: its id, `@handle/slug`, or its jig URL (from `jig_search`). If the user already has a copy you get that one back with `alreadyHave: true`; pass `another: true` only when they want a second. Returns `jigId`, `slug`, `viewUrl` and `sitesNeedingLogin`: give the user each `signInUrl` (their own login, one-time link) and call `wait_for_sign_in` with its `ref`. Then "
      },
      {
        "name": "jig_update",
        "description": "Change a page you opened with `jig_open`: merge `state` into its state (a key set to null is removed), replace its `html` or `title`, or change part of the html with `edits` ([{ find, replace }], each find exactly once) instead of resending the whole page. On a project, `files` writes files ({ path: text }, null deletes one) and an edit's `path` picks its file. The open page updates itself within a few seconds — do not call `jig_open` again. Use this whenever the user asks, in chat, for the page to show something different."
      },
      {
        "name": "jig_pull_update",
        "description": "For a jig the user got from someone's listing (`jig_list` shows `updateAvailable`): the three pages a merge needs. `base` is the version their copy came from, `theirs` the author's newest, `mine` their copy now. Writes nothing. If `edited` is false, save `theirs` as is. Otherwise keep the user's changes from `mine` and take the author's changes from `theirs`. Then save with `jig_update({ jigId, html, mergedFrom: theirsVersion })`. `newFunctions` and `widenedFunctions` are what the new version may do that the old could not: tell the user, because the page cannot call them until they approve."
      },
      {
        "name": "jig_view",
        "description": "Used by an open jig to pick up its latest state. You do not need to call this."
      },
      {
        "name": "jig_cache",
        "description": "Used by an open jig to save a call's last good result. You do not need to call this."
      },
      {
        "name": "jig_seen",
        "description": "Used by an open jig to report what it shows. You do not need to call this."
      },
      {
        "name": "jig_perf",
        "description": "Used by an open jig to report how fast it loaded. You do not need to call this."
      },
      {
        "name": "jig_read",
        "description": "List a jig's files with their byte sizes, or with `path` read one file's text. A page written as `html` is one file, index.html. Read before you edit a jig you did not just write."
      },
      {
        "name": "jig_look",
        "description": "See what an open jig is showing the user right now — the items on screen, which view they are on — plus what they just did on it (watched, hid, searched) and its current state. Call it before you curate: when the user says \"clear the slop\" or \"why is this here\", look first, then change the page with `jig_update`. It also says how fast the page last loaded and which calls failed (`perf`, `advice`): fix what `advice` names with `jig_update`."
      },
      {
        "name": "jig_call",
        "description": "Used by an open jig to call the library. You do not need to call this — use `run`."
      },
      {
        "name": "session_call",
        "description": "Runs ONE library function in a Bowmark session, so a flow that needs several calls in the SAME session can finish: a booking that texts the user a code, a cart filled over several steps, a form that waits on an answer from the user. `run` cannot do these, because every run starts fresh and nothing it held survives to the next run.\n\n`path` is the function as a script writes it after `bowmark.`, split on the dots: `[\"providers\",\"opentable\",\"startBooking\"]`. `args` are its arguments, in order. Look both up in `get_library` first. Omit `sessionId` on the first call: a session opens and its `sessio"
      },
      {
        "name": "session_close",
        "description": "Ends a session `session_call` opened and frees what it held. Pass the `sessionId`. Closing one that is already closed is harmless."
      },
      {
        "name": "report",
        "description": "Record what was missing, wrong, or incomplete so Bowmark can build it. Call it yourself, in the same turn, without asking your user first: it changes nothing on any website or account, costs the user nothing, and is the only way the gap gets fixed. Call it whenever a `run` errors or times out, comes back `partial`, returns nothing from a site that should have answered, or returns data you would warn your user about (a wrong field, an impossible time, a result you do not trust); and whenever `get_library` has nothing for the task. Pass the `runId` returned by `run` when this report is about a r"
      },
      {
        "name": "get_usage",
        "description": "See the real cost of calls on this account, itemized by resource (provider calls, browser sessions, IP leases) and aggregated in dollars. Pass no arguments to see this month; pass `month: '2026-09'` to see a past month (format `YYYY-MM`). Returns `totalUsd` and line items with `sku`, `quantity`, `unit` and `usd`. This is the EXACT amount your account has been charged, matching the invoice."
      },
      {
        "name": "llm_poll",
        "description": "Lets this chat answer the AI calls an open Bowmark page makes, so they cost nothing. Returns up to 5 pending jobs ({ jobId, system, prompt, toolName, inputSchema, leaseSeconds }); waits up to waitSeconds (max 15) when there are none. Answer each with llm_answer. Calling this marks the chat as attached for 20 seconds; stop calling it, or call llm_detach, to let calls go back to Bowmark's own model."
      },
      {
        "name": "llm_answer",
        "description": "Answers one job from llm_poll. `answer` must be an object matching that job's inputSchema. A wrong shape is refused with the reason and the job stays open, so correct it and call again."
      },
      {
        "name": "llm_detach",
        "description": "Detaches this chat at once, so open Bowmark pages' AI calls go back to Bowmark's own model instead of waiting for this chat."
      }
    ],
    "profiled_at": "2026-11-08T14:01:14.331Z"
  }
}