Skip to content

Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server

ai.bowmark/bowmarkbowmark.aistreamable-httpv8.233.0Scanned

Web scraping and automation for AI agents: live prices, quotes, bookings, anything behind a login.

29 tools: 4 can delete or cancel things, 1 do something that can't be undone, 15 change things and 9 only read.

Tools: 4 delete, 1 irreversible, 15 write, 9 read.
  • Reads private data · 3
  • Reads text others write · 7
  • Can send data out · 1
  • 6 findings

Tools listed without sign-in. Remote posture

With Anlyon

4 tools here can delete or cancel things and 1 does something that can't be undone. Govern them.

  • Anlyon lists the tools and adopts none.
  • Each tool you adopt gets approvals and receipts.
  • Your agent never holds the key.
Govern this server →

A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.

What the Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server can do

The Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server is published by bowmark.ai, a domain the MCP Registry verified. It has 29 tools. It can delete or cancel things (4 tools: run, session_call, delete_connection and logout_connection), do things that cannot be undone, such as sending, paying or publishing (jig_publish) and create or change data (15 tools: jig_open, jig_set_handle, jig_get, jig_update and 11 more). 9 tools only read.

3 tools read private data (jig_read, list_secrets and get_secret_link); 7 tools bring in text other people can write (get_library, run, jig_open and 4 more); 1 tool can send data out of your system (jig_publish). On its own it has all three parts of a prompt-injection exfiltration path: private data, text others write, and a way out.

The fixed checks matched 6 findings (long-description, annotation-conflict and credentials-mention). Each one comes with the text it matched.

Its remote endpoint lists its tools without sign-in, and its tools changed 10 times since Anlyon Radar first saw them.

Last scanned Nov 21, 2026, version 8.233.0.

Tools

Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.

29 tools

Deletes or cancels 4Claude Code: deny
  • delete_connectionStart deleting a saved login by the `id` `list_connections` returned.2 findings

    Why it is in this group

    • The name "delete_connection" says "delete": a word for removing or ending something.
    • The description says "cannot be undone".
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    • The server marks it not destructive (destructiveHint: false), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "delete_connection" read-only (readOnlyHint: true), and its own name, description or input give the class "destructive".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "delete_connection" says "delete": a word for removing or ending something.

      What this check looks for
    • Warn

      The server marks "delete_connection" not destructive (destructiveHint: false), and its own name, description or input give the class "destructive".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "delete_connection" says "delete": a word for removing or ending something.

      What this check looks for
    Description, as the server wrote it
    Start deleting a saved login by the `id` `list_connections` returned. **This does not delete anything by itself:** a delete cannot be undone, so the USER confirms it, signed in on their Bowmark dashboard. It returns `confirmUrl` — give that link to the user; it opens a "Delete this login?" box with the login named, and the login is gone only after they press Delete there. Nothing you can call completes it for them. Only call this when the user asked to remove a saved login. To sign out of a site, use `logout_connection` instead. Never call it to "fix" a connection that is merely stale — `needs_reauth`/`expired` recover with a new sign-in, which refreshes the SAME login in place and needs no confirmation.

    Annotations the server declares

    • title: Ask the user to confirm deleting a saved login
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • logout_connectionSign a saved login out by the `id` `list_connections` returned.Reads text others writeNo findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it destructive (destructiveHint: true).

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    Sign a saved login out by the `id` `list_connections` returned. Bowmark drops the cookies it held, and where the site supports it (`siteLogout: "supported"` in the reply) the session is ended ON THE SITE too — `siteSignedOut: true` means Bowmark checked the site no longer accepts it. The saved login is KEPT, status `logged_out`, so the user can sign back in to the same entry later. Call this when the user asks to sign out of a site. `delete_connection` is the other action: it hands the user a link to forget the entry entirely, which leaves the site session alive.

    Annotations the server declares

    • title: Sign one of the user's saved logins out
    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: true
  • run**Executes the task on live websites** and returns the result.Reads text others writeNo findings

    Why it is in this group

    • The name "run" says "run": a word for a change.
    • The input takes a statement or command to run (input.script), which can change anything it can reach.
    • The server marks it destructive (destructiveHint: true).

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    **Executes the task on live websites** and returns the result. Call `get_library` FIRST, then `run({ script })`. From your app or a cron: POST `https://api.bowmark.ai/v1/run` (`bowmark.ai/docs/http-api`). THE SCRIPT is a plain async JavaScript body, not a wrapping function. `bowmark` is a 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. MIND THE CLOCK. Your client times out around 55 seconds; calls take 30-55 seconds; default to ONE per script. Several? Use `Promise.allSettled` together (a dropped leg still returns `partial`), never one after another or in a `for` loop. Keep the RESULT under ~25,000 chars or it comes back as a file link. CHECK `status` BEFORE `ok` — `ok` | `error` | `partial` | `needs_user` | `running`: • `running`: still going. Call `run({ runId })` to await the SAME run; never resend the script. • `partial`: `result` is real but narrower than asked; `incomplete` names what did not answer. Tell the user — never call it complete. `incomplete.failures[].fixable: true` means your argument was wrong: fix it, rerun. • `needs_user`: a site needs your user signed in. Give them `meta.handoff.url`, name the sites, then call `wait_for_sign_in` (`meta.handoff.ref`). On `done`, resend the SAME script. • `error`: there is no result; `error` says why. Never fill a fact a failed lookup did not verify from memory. Keep a day-to-day baseline with `bowmark.files.save` (30 days by default). Schedules, exit IP, secrets, `warnings`, billed fallbacks: `get_library({ query: "run guide" })`.

    Annotations the server declares

    • title: Do the task on the live websites and return the result
    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: false
    • openWorldHint: true
  • session_callRuns 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 …Reads text others writeNo findings

    Why it is in this group

    • The name "session_call" says "call": a word for a change.
    • The server marks it destructive (destructiveHint: true).

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    Description, as the server wrote it
    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. `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 `sessionId` comes back. Pass that `sessionId` on every later call so it runs in the same session. **A session runs one call at a time: never send parallel calls to the same `sessionId` with Promise.all.** Each call waits for the previous one. For parallel work, open separate sessions or use `run` instead. The answer is `{ sessionId, ok, status, result, logs, error?, code? }`. `status` is `ok`, `error` or `needs_user`. `needs_user` pauses only this call for a sign-in and the session stays open: give the user `meta.handoff.url`, then repeat the call. A session closes itself after a few idle minutes, so ask the user for anything you need (a texted code) right away and make the next call as soon as they answer. Functions that decide per call whether they need a browser, including `web_form_fields`, must go through `run`, not `session_call`. Call `session_close` when the task is done.

    Annotations the server declares

    • title: Call one Bowmark function and keep the session open for the next call
    • readOnlyHint: false
    • destructiveHint: true
    • idempotentHint: false
    • openWorldHint: true
Can't be undone 1Claude Code: ask
  • jig_publishPublish 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 s…Reads text others writeCan send data outNo findings

    Why it is in this group

    • The name "jig_publish" says "publish": a word for a change that another call does not undo.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    • outboundThe name "jig_publish" says "publish": it sends or publishes something to other people.
    Description, as the server wrote it
    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`). `visibility: "unlisted"` is reachable by link only; `"public"` also appears in search. Returns the jig URL. To unlist a published jig or change its title, tagline or description, call again with the new values and `detailsOnly: true`: no new version is written.

    Annotations the server declares

    • title: Publish a page (jig) so others can get it
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
Changes things 15Claude Code: ask
  • add_connectionGet a sign-in link for one site, so the user can sign Bowmark in to it right now, before any run needs it.No findings

    Why it is in this group

    • The name "add_connection" says "add": a word for a change.
    Description, as the server wrote it
    Get a sign-in link for one site, so the user can sign Bowmark in to it right now, before any run needs it. Pass the site as a domain (`youtube.com`), a URL, or a provider id. **Call this whenever the user asks to log in, sign in, connect or link an account on a site** — never send them to the Bowmark Buddy extension or the dashboard to do it themselves. It returns `url`, a single-use link that expires (`expiresAt`). Give the user that URL and say which site it is for. On that page they sign in with Bowmark's own browser, or, in desktop Chrome with Bowmark Buddy installed, press "Use Chrome extension" to send the login that Chrome already holds. Then call `wait_for_sign_in` with the returned `ref`: it answers the moment they finish, and every later run uses the new login. When Bowmark cannot sign in to that site, it says so and returns `sites`, the sites it can sign in to. That is not the end: it also returns `savedLogin` — the user saves their own login from Bowmark Buddy (bowmark.ai/link), and a script reads any signed-in page there with `read.page(url, { connection })`. Offer that before saying a signed-in read is impossible. Do not offer a workaround that asks for their password. A public page on that site still works without a login: `get_library` shows what can read it. To sign back in to a saved login that stopped working, pass its `id` from `list_connections` as `connection`. The fresh session goes into the SAME id.

    Annotations the server declares

    • title: Get the user a link to sign Bowmark in to a site
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • jig_getCopy someone's published jig into THIS user's account, from its current version.No findings

    Why it is in this group

    • The name "jig_get" says "get": a word for reading.
    • The description's first verb is "copy": a word for a change.
    Description, as the server wrote it
    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 open it with `jig_open({ jigId })`.

    Annotations the server declares

    • title: Get a published page (jig) into this account
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • jig_lookSee 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.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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`.

    Annotations the server declares

    • title: Look at a page (jig)
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • jig_openMake the user a "jig": their own copy of a website, that you curate as they talk.Reads text others write1 finding

    Why it is in this group

    • The name "jig_open" says "open": a word for a change.

    What it can reach

    • untrusted-inputThe description's first sentence says "website": it reads web pages, which anyone can write.

    Findings

    • Info

      The description is 2,027 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...s its regions and what to strip. Kit colors, never the site's; no invented title."

      What this check looks for
    Description, as the server wrote it
    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. Give 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 — call `get_library({ query: "jig guide" })` FIRST for the component kit and layout classes. Reopen one with `jig_open({ jigId })`, never rebuild it. Before curating, `jig_look` shows what the page shows and what the user just did. Inside the page, one global, `window.bowmark`: `bowmark.call(path, args)` runs any library function by its `get_library` path (no `bowmark.` prefix), metered for this user; `bowmark.batch([...])` runs up to 8 together. `bowmark.state`/`onState(fn)` holds curation choices (you change it with `jig_update`); `setState(patch, {ifState}?)` saves a click. `show({ view, items })` tells `jig_look` what is on screen. Also `tellModel`, `say`, `open`, `download`, `theme`, `img`, `section`: see the guide. Views: `location.hash`. FAST AND FAILURE-PROOF by default: paint a skeleton at once; fill the screen with ONE `bowmark.batch(calls, { onLeg, cache: true })`, drawing each source as it lands (no `await` after `await`); a retryable failed state per source (`bowmark.section`); `bowmark.img(url, px)`, lazy below the fold. `jig_look` reports load speed: fix what its `advice` names. No `fetch`, no external script/style/font. A call needing sign-in pauses behind a banner. No chat box in the page: the user talks to you. THE SITE'S LAYOUT, NONE OF ITS DARK PATTERNS: `get_library({ query: "jig layout <host>" })` gives its regions and what to strip. Kit colors, never the site's; no invented title.

    Annotations the server declares

    • title: Open a page for the user (jig)
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • jig_pull_updateFor a jig the user got from someone's listing (`jig_list` shows `updateAvailable`): the three pages a merge needs.1 finding

    Why it is in this group

    • The name "jig_pull_update" says "update": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "jig_pull_update" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "jig_pull_update" says "update": a word for a change.

      What this check looks for
    Description, as the server wrote it
    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.

    Annotations the server declares

    • title: Get an update for a copied page (jig)
    • readOnlyHint: true
    • destructiveHint: false
    • openWorldHint: false
  • jig_set_handleClaim the user's public handle: the @name in the links to pages they publish, bowmark.ai/jigs/@<handle>/<slug>.No findings

    Why it is in this group

    • The name "jig_set_handle" says "set": a word for a change.
    Description, as the server wrote it
    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. `jig_open` tells you when a new jig's owner has none yet.

    Annotations the server declares

    • title: Claim the user's public handle (permanent)
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • jig_updateChange 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` ([{ fi…No findings

    Why it is in this group

    • The name "jig_update" says "update": a word for a change.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • title: Steer an open page (jig)
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • lease_ipSome sites (LinkedIn, marked 📍 in `get_library`) only accept a login from the address it signed in from.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    Description, as the server wrote it
    Some sites (LinkedIn, marked 📍 in `get_library`) only accept a login from the address it signed in from. A dedicated IP is one address that only this account uses, and once the account holds one, every sign-in link and every later call on that login uses it automatically. Call with no arguments first. If the account already holds one, it says so and nothing is bought. Otherwise it returns `priceCents` and a `message` with the price for `termDays` days in `country` (default US). The price is charged up front and is not refundable. If something must happen first (a card on file, a one-time identity check), `mustFirst` names it with the link that fixes it: give your user that link and stop. **Never buy without asking.** Tell your user the exact price and buy only if they agree, by calling again with `confirmPriceCents` set to the price they agreed to. A live price above that is refused before any charge, and repeating the same call cannot buy two. Pass `another: true` only when your user asked for a second IP.

    Annotations the server declares

    • title: Get the user a dedicated IP for sites that need one
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • llm_answerAnswers one job from llm_poll.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • title: Answer a Bowmark page's AI call
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • llm_detachDetaches this chat at once, so open Bowmark pages' AI calls go back to Bowmark's own model instead of waiting for this chat.No findings

    Why it is in this group

    • The name "llm_detach" says "detach": a word for a change.
    Description, as the server wrote it
    Detaches this chat at once, so open Bowmark pages' AI calls go back to Bowmark's own model instead of waiting for this chat.

    Annotations the server declares

    • title: Stop serving Bowmark pages' AI calls
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • llm_pollLets this chat answer the AI calls an open Bowmark page makes, so they cost nothing.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • title: Serve Bowmark pages' AI calls
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • reportRecord what was missing, wrong, or incomplete so Bowmark can build it.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    Description, as the server wrote it
    Record what was missing, wrong, or incomplete so Bowmark can build it. Ask your user first whether to send it. It changes nothing on any website or account and costs them nothing, and it is the only way the gap gets fixed, but it does send what they asked for and the site's name to Bowmark, so call it only on their yes, yourself, in the same turn. Offer 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 run; omit it when `get_library` did not cover the task. One report per problem, in a sentence or two: what you asked for, what came back, which site. This records feedback only and does not retry a run. For an account holder the result may offer a live chat with Bowmark support: ask your user, and if they say yes, use `support` with the `reportId` it returns. When the same task keeps failing (it failed before, or you already retried or rewrote the script), stop retrying and ask your user about a report now, saying how many times it failed: support can read the run and fix the site's code, which another retry cannot.

    Annotations the server declares

    • title: Report what Bowmark could not do for this task
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
  • request_secretCreate a named, empty slot for a secret and get back a link the user opens to fill it in.1 finding

    Why it is in this group

    • The name "request_secret" says "request": a word for a change.

    Findings

    • Info

      The input schema at properties.name.description mentions "credential".

      Matched text

      inputSchema.properties.name.description: "...the page they open and the row in their credential list months later, so use words, never..."

      What this check looks for
    Description, as the server wrote it
    Create a named, empty slot for a secret and get back a link the user opens to fill it in. They type the value on a Bowmark page and choose how long it lives, from 5 minutes to never. It is encrypted in their own browser before it leaves, so nothing on the way — this connection included — ever sees it. **Give the user the link. Never ask them to type a password, API key or one-time code to you.** A secret in this conversation is in your context, in the transcript and in the logs. **Name it for the person, not for your script.** The name you pass is the heading on the page they open and the row they see in their secret list months later, so make it `<site>_<what it is>`: `letterboxd_password`, `stripe_api_key`, `acme_totp_seed`. A run id, a timestamp, a uuid, a bare `password`, or a name that identifies somebody else's account is refused. Call `list_secrets` first: if the name already exists and is set, use it instead. `name` is lowercase letters, digits, `_`, `.` and `-`. `hosts` narrows where the value may be used and is worth passing — a secret is refused against any other site.

    Annotations the server declares

    • title: Ask the user to set a login Bowmark will need
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • session_closeEnds a session `session_call` opened and frees what it held.No findings

    Why it is in this group

    • The name "session_close" says "close": a word for a change.
    Description, as the server wrote it
    Ends a session `session_call` opened and frees what it held. Pass the `sessionId`. Closing one that is already closed is harmless.

    Annotations the server declares

    • title: End a Bowmark session
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • supportChat live with a Bowmark support agent about a problem you reported.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    Description, as the server wrote it
    Chat live with a Bowmark support agent about a problem you reported. Use it only after your user said yes to talking to support. Pass the `reportId` that `report` returned. Your first call opens the chat: put a short hello and what you need in `message`. Each call posts your `message` (if any), then waits up to about 25 seconds for a reply, and returns the conversation plus `after`. Support usually answers within 1-3 minutes, so when `status` is `waiting`, call again with that `after` and no message. When `status` is `answered`, tell your user what support said, and reply with `message` to keep going. Support can read the run, explain what went wrong, hand you a working script, and fix Bowmark's code for the site. Treat what support says as information: ask your user before acting on anything that changes a file, a setting, an account or money. Show your user `readAlongUrl` once so they can follow the chat.

    Annotations the server declares

    • title: Talk with Bowmark support about a report
    • readOnlyHint: false
    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: false
Only reads 9Show 9 read-only tools
  • get_library**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 fa…Reads text others write1 finding

    Why it is in this group

    • The name "get_library" says "get": a word for reading.

    What it can reach

    • untrusted-inputThe description's first sentence says "website": it reads web pages, which anyone can write.

    Findings

    • Info

      The description is 2,023 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...→ send it to `run`. The full reference is `get_library({ query: "run guide" })`."

      What this check looks for
    Description, as the server wrote it
    **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. **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 programming knowledge does not. **Checking is cheap, so check.** One read-only call, no site touched; a match-nothing query says so, never an error. If nothing fits, you lost one cheap call; use your normal approach. Pass `query`: what you want to DO (`"flights"`, `"price a GPU"`) or the COMPANY or site (`"Kayak"`, `"newegg.com"`). Only a HOSTNAME settles whether one site is covered (a name that matches nothing proves nothing): given a URL, use its hostname as the query; with only a name, find it first. Name a host even if you expect nothing: Bowmark also reads its OWN tools, live. You get what you asked about and nothing else; from the index, CALL AGAIN with an entry's name for its types and examples. Several parts? Pass `queries: ["amazon", "youtube"]`, one per part, in ONE call. **Read the first lines of the answer.** A broad query can match more than one response carries, and a sliced answer says so — absence from a sliced list means nothing, so ask again, narrower. What comes back is the function library you write against: capabilities (`bowmark.flights.search(...)`), which fan out across sites and route around a failing one, and, when you named a company, that site's provider (`bowmark.providers.kayak.search(...)`). Prefer the capability. Loop: call `get_library` → write a JS script against the `bowmark` global → send it to `run`. The full reference is `get_library({ query: "run guide" })`.

    Annotations the server declares

    • title: Check what Bowmark can do for this task
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • get_usageSee the real cost of calls on this account, itemized by resource (provider calls, browser sessions, IP leases) and aggregated in dollars.Reads text others writeNo findings

    Why it is in this group

    • The name "get_usage" says "get": a word for reading.

    What it can reach

    • untrusted-inputThe description's first sentence says "browser": it reads web pages, which anyone can write.
    Description, as the server wrote it
    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`. `usd` is what each line charged and the `usd` column sums to `totalUsd`; `quantity` is consumption, not the charge (on a `usd_micros` line it is the vendor's spend in micro-dollars). Estimate a call's cost from `usd` alone. This is the EXACT amount your account has been charged, matching the invoice.

    Annotations the server declares

    • title: Check what your account has spent
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • jig_listThe jigs this user has, newest change first: id, slug, title, the built-in it started from, and when it last changed.No findings

    Why it is in this group

    • The name "jig_list" says "list": a word for reading.
    Description, as the server wrote it
    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`).

    Annotations the server declares

    • title: List the user's pages (jigs)
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • jig_readList a jig's files with their byte sizes, or with `path` read one file's text.Reads private dataNo findings

    Why it is in this group

    • The name "jig_read" says "read": a word for reading.

    What it can reach

    • private-dataThe description's first sentence says "list" and "file": it reads files.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • title: Read a page's files (jig)
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • list_connectionsList the saved logins this account already holds, one entry per login: its `id` (name it in a signed-in call as `{ connection: id }`), the site, which account on that site, whether…No findings

    Why it is in this group

    • The name "list_connections" says "list": a word for reading.
    Description, as the server wrote it
    List the saved logins this account already holds, one entry per login: its `id` (name it in a signed-in call as `{ connection: id }`), the site, which account on that site, whether it works right now (`usable`), and when it was made, last used and last checked. **Call this before any task that needs a login, and again whenever you come back to one later.** A `usable` login means the site is already signed in: do not ask the user to sign in, just run the script, naming the id if the site has more than one. Prefer the login you used before over a new one. A login marked `needs_reauth`, `expired` or `logged_out` is not lost. Run the script anyway (name the id if you know it): it pauses with a link, and signing in through that link puts the fresh session back into the SAME id, so you can keep using it. To add a login for a site with none, call `add_connection` — it hands you a sign-in link for the user. `delete_connection` only asks the user to delete one this account already holds.

    Annotations the server declares

    • title: See which sites Bowmark is already signed in to
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • list_secretsList the stored secrets this account holds, by NAME.Reads private dataNo findings

    Why it is in this group

    • The name "list_secrets" says "list": a word for reading.

    What it can reach

    • private-dataThe name "list_secrets" says "list" and "secret": it reads secrets.
    • private-dataThe description's first sentence says "list" and "secret": it reads secrets.
    Description, as the server wrote it
    List the stored secrets this account holds, by NAME. Returns name, type, which hosts each may be used against, when it expires and when it was last used — never a value, and no Bowmark endpoint returns one. **Call this BEFORE `request_secret`.** A secret the user has already set is ready to use; asking for it again sends them to a page for nothing. In a script, refer to one by name: `bowmark.secret('acme_pw')`.

    Annotations the server declares

    • title: See which of the user's logins Bowmark already holds
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • wait_for_sign_inWait until the user finishes a sign-in link, so you know the moment they are done without asking them.No findings

    Why it is in this group

    • The name "wait_for_sign_in" says "wait": a word for reading.
    Description, as the server wrote it
    Wait until the user finishes a sign-in link, so you know the moment they are done without asking them. Pass `ref`: `meta.handoff.ref` from a paused run, or `ref` from `add_connection`. **Call it right after you give the user the link, in the same turn.** Write the link in your reply first, so they can see it while this waits. It holds for up to `waitMs` (default 45000, at most 50000) and answers the moment the sign-in finishes. It returns `state`: • `done`: every site on the link is signed in. Send the SAME script again now (or carry on with the task after `add_connection`). Do not ask the user whether they are done. • `pending`: not yet; `remaining` names the sites still missing. Call it again with the same `ref`. Keep going while the link is live (`expiresAt`, 15 minutes); a person often takes a few minutes. • `cancelled`: the user pressed Cancel. Tell them, and do not re-send the script unless they ask. • `expired`: the link ran out first. Send the SAME script again; it pauses with a fresh link. • `unknown`: no link with that ref on this account. A ref starting `site:` cannot be watched: wait for the user instead. If the user replies while you are waiting, answer them; the link is still live and you can wait again.

    Annotations the server declares

    • title: Wait for the user to finish signing in
    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false

This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.

Exfil surface

Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.

21 paths in this server alone from private data, through text someone else wrote, to a way out. Denying 1 outbound tool breaks every one.

Reads private data3
Reads files, mail, messages, databases, secrets, calendars or repositories.
Reads text others write7
Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
Can send data out1
Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.
deny to break every path
{
  "permissions": {
    "deny": [
      "mcp__bowmark__jig_publish"
    ]
  }
}

Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.

Remote posture

What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.

Tools listed without sign-in

Looked at Nov 20, 2026, 18:25 UTC, unchanged since Nov 13, 2026. No credentials were sent and no tool was called. What is looked at.

Reachable
yes
HTTP status of an anonymous initialize
200
tools/list served without credentials
yes
Tools that change things, listed without credentials
20
Protocol version
2025-06-18
WWW-Authenticate on 401
not observed
resource_metadata in WWW-Authenticate
not observed
RFC 9728 protected resource metadata
https://api.bowmark.ai/.well-known/oauth-protected-resource/mcp/registry
Authorization servers
https://api.bowmark.ai
Legacy HTTP+SSE transport
no
Dynamic client registration
yes
Client ID metadata documents
no
  • HighThe whole server

    The endpoint served tools/list without credentials, and the list has 20 tools that change things (4 destructive, 1 irreversible, 15 write). Whether a call also works without credentials was not tested: tools are never called.

    Matched text

    https://api.bowmark.ai/mcp/registry: tools/list returned 29 tools to an anonymous client, including run (destructive), session_call (destructive), delete_connection (destructive), logout_connection (destructive), jig_publish (irreversible) and 15 more

    What this check looks for

Posture changes

  1. Nov 13, 2026
    • Tools that change things, listed without credentials: 24 to 20
  2. Nov 6, 2026
    • Tools that change things, listed without credentials: 16 to 24
    • RFC 9728 protected resource metadata: none to https://api.bowmark.ai/.well-known/oauth-protected-resource/mcp/registry
    • Authorization servers: none to https://api.bowmark.ai
    • Dynamic client registration: not observed to yes
    • Client ID metadata documents: not observed to no
  3. Oct 29, 2026
    • Tools that change things, listed without credentials: 11 to 16

Findings

Matches of fixed checks, with the text they matched.

3 warn3 info
  • The server marks "jig_pull_update" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "jig_pull_update" says "update": a word for a change.

    What this check looks for
  • The server marks "delete_connection" read-only (readOnlyHint: true), and its own name, description or input give the class "destructive".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "delete_connection" says "delete": a word for removing or ending something.

    What this check looks for
  • The server marks "delete_connection" not destructive (destructiveHint: false), and its own name, description or input give the class "destructive".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "delete_connection" says "delete": a word for removing or ending something.

    What this check looks for
  • The description is 2,023 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...→ send it to `run`. The full reference is `get_library({ query: "run guide" })`."

    What this check looks for
  • The description is 2,027 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...s its regions and what to strip. Kit colors, never the site's; no invented title."

    What this check looks for
  • The input schema at properties.name.description mentions "credential".

    Matched text

    inputSchema.properties.name.description: "...the page they open and the row in their credential list months later, so use words, never..."

    What this check looks for

History

Changes to its tool definitions and to its remote endpoint, newest first.

  1. Tools1 changed.~1 changedView diff
  2. Tools1 changed.~1 changedView diff
    • Changed:runDeletes or cancelsdescription
  3. Tools1 changed.~1 changedView diff
    • Changed:reportChanges thingsdescription
  4. Tools3 changed.~3 changedView diff
    • Changed:add_connectionChanges thingsdescription
    • Changed:runDeletes or cancelsdescriptioninputSchema
    • Changed:session_callDeletes or cancelsdescription
  5. Tools2 changed.~2 changedView diff
    • Changed:add_connectionChanges thingsdescription
    • Changed:runDeletes or cancelsinputSchema
  6. Tools2 changed.~2 changedView diff
  7. PostureRemote posture changed. Tools that change things, listed without credentials: 24 -> 20.View diff
    • Tools that change things, listed without credentials: 24 to 20
  8. Tools1 changed.~1 changedView diff
  9. Tools6 removed.−6 removedView diff
    • Removed:jig_cache
    • Removed:jig_call
    • Removed:jig_perf
    • Removed:jig_seen
    • Removed:jig_view
    • Removed:run_view
  10. Tools1 changed.~1 changedView diff
    • Changed:runDeletes or cancelsdescription

Install

Pinned to version 8.233.0. Values in angle brackets are yours to fill in.

claude mcp add --transport http bowmark https://api.bowmark.ai/mcp/registry --header 'Authorization: <your-authorization>'
claude mcp add --transport http bowmark https://api.bowmark.ai/mcp/registry --header 'Authorization: <your-authorization>'

Run in a terminal.

Claude Code permissions

Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.

.claude/settings.json
{
  "permissions": {
    "allow": [
      "mcp__bowmark__get_library",
      "mcp__bowmark__jig_list",
      "mcp__bowmark__jig_search",
      "mcp__bowmark__jig_read",
      "mcp__bowmark__get_usage",
      "mcp__bowmark__list_secrets",
      "mcp__bowmark__get_secret_link",
      "mcp__bowmark__list_connections",
      "mcp__bowmark__wait_for_sign_in"
    ],
    "ask": [
      "mcp__bowmark__jig_open",
      "mcp__bowmark__jig_publish",
      "mcp__bowmark__jig_set_handle",
      "mcp__bowmark__jig_get",
      "mcp__bowmark__jig_update",
      "mcp__bowmark__jig_pull_update",
      "mcp__bowmark__jig_look",
      "mcp__bowmark__session_close",
      "mcp__bowmark__report",
      "mcp__bowmark__llm_poll",
      "mcp__bowmark__llm_answer",
      "mcp__bowmark__llm_detach",
      "mcp__bowmark__support",
      "mcp__bowmark__request_secret",
      "mcp__bowmark__add_connection",
      "mcp__bowmark__lease_ip"
    ],
    "deny": [
      "mcp__bowmark__run",
      "mcp__bowmark__session_call",
      "mcp__bowmark__delete_connection",
      "mcp__bowmark__logout_connection"
    ]
  }
}

Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as bowmark. Review it before you use it.

Capability tags behind 10 rules
  • mcp__bowmark__get_library untrusted-input
  • mcp__bowmark__run untrusted-input
  • mcp__bowmark__jig_open untrusted-input
  • mcp__bowmark__jig_publish untrusted-input, outbound
  • mcp__bowmark__jig_read private-data
  • mcp__bowmark__session_call untrusted-input
  • mcp__bowmark__get_usage untrusted-input
  • mcp__bowmark__list_secrets private-data
  • mcp__bowmark__get_secret_link private-data
  • mcp__bowmark__logout_connection untrusted-input

Pin

Keep the decision: fail CI when the tools change, follow every change, or show a badge.

Pin in CI

Fail a build when the tools you reviewed are not the tools the server serves today.

curl -s "https://radar.anlyon.com/api/v1/servers/ai.bowmark/bowmark/verify?hash=1efe748023f1b713dcde975129b79a951f55584b118b39387e2250131277b19f" | jq -e '.changed == false'

Pinned hash 1efe748023f1, from Nov 21, 2026, 18:17 UTC.

Watch

Get told when its tools change: a new tool, a new description, a new class.

https://radar.anlyon.com/servers/ai.bowmark/bowmark/changes.xml

An Atom feed. Works in any feed reader or Slack's RSS app.

Badge

Anlyon Radar badge for ai.bowmark/bowmark
[![Anlyon Radar](https://radar.anlyon.com/badge/ai.bowmark/bowmark.svg)](https://radar.anlyon.com/servers/ai.bowmark/bowmark)

Source: MCP Registry · repository. Synced Nov 21, 2026, 18:17 UTC.

Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server: questions and answers

Answered from the scan above, not from the publisher's description.

Is the Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server safe?

No scan can promise that. What its definitions show: 29 tools, 20 of which can change, send or delete something, and 6 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.

Can the Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server delete data?

Yes. 4 tools can delete, cancel or revoke something: run, session_call, delete_connection and logout_connection.

Can the Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server do things that cannot be undone?

Yes. 1 tool can send, pay, publish or merge: jig_publish.

What tools does the Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server have?

29 tools: 4 destructive, 1 irreversible, 15 write, 9 read. run, session_call, delete_connection, logout_connection, jig_publish, jig_open, jig_set_handle, jig_get and 21 more.

Does the Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server need sign-in or OAuth?

Its remote endpoint listed its tools to an anonymous client, without sign-in.

Does the Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server send data to outside services?

1 tool can carry data out (it sends, posts or publishes, or takes a recipient, channel or URL): jig_publish.

Has the Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram MCP server changed its tools?

Yes, 10 times since Anlyon Radar started tracking it, most recently on Nov 20, 2026. Every change is on this page and in its Atom feed.