Skip to content
MCP server

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

Typed website functions for agents, as an alternative to driving a browser

Status and history

Answered our latest tool-list check 15 hours ago with 29 tools. It will be marked verified after 3 successful checks in 7 days.

Install
Pricing
Freemium
Platforms
API, CLI
Runs
Locally or Remotely
Version
8.227.0
Listing updated
4 days ago

About Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram

Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram is a freemium MCP server for design and media. It can run locally on your machine or as a hosted remote server.

Bowmark converts sites into libraries of typed JavaScript functions, so an agent writes a short script such as a hotel search and gets structured data back without opening a browser. The site lists capabilities per site: YouTube has 28, Amazon 15, Google Maps 11, and Calendly and Expedia 4 each, with others for LinkedIn, Reddit, Airbnb and Instagram.

It claims up to 20 times lower cost and 5 times faster than a browser agent, citing a replay where a hotel booking used about 1,200 tokens against about 50,000. Those figures are the vendor's own demonstration.

Charging is in US dollars for resources used: proxy bandwidth, rendering time, captcha solves and paid data APIs, including failed calls. Every account starts with $10 free, and reading the library is free. It runs over stdio from PyPI or npm, or as a hosted endpoint.

Install

Run in a terminal

claude mcp add --transport http bowmark https://api.bowmark.ai/mcp/registry

Add to Settings → Connectors → Add custom connector

https://api.bowmark.ai/mcp/registry
Install in CursorOpens Cursor, which asks you to confirm. Or add it by hand:

Add to ~/.cursor/mcp.json

{
  "mcpServers": {
    "bowmark": {
      "url": "https://api.bowmark.ai/mcp/registry"
    }
  }
}
Install in VS CodeOpens VS Code, which asks you to confirm. Or add it by hand:

Add to .vscode/mcp.json

{
  "servers": {
    "bowmark": {
      "type": "http",
      "url": "https://api.bowmark.ai/mcp/registry"
    }
  }
}

Add to ~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "bowmark": {
      "serverUrl": "https://api.bowmark.ai/mcp/registry"
    }
  }
}

Add to your client's MCP settings (most use this shape)

{
  "mcpServers": {
    "bowmark": {
      "type": "http",
      "url": "https://api.bowmark.ai/mcp/registry"
    }
  }
}

Configuration

  • BOWMARK_API_KEYRequired. Your Bowmark API key. Sign up at https://bowmark.ai/sign-up, then create a key at https://bowmark.ai/dashboard/keys. Your first $10 of usage is free.Required
  • BOWMARK_API_KEYRequired. Your Bowmark API key. Sign up at https://bowmark.ai/sign-up, then create a key at https://bowmark.ai/dashboard/keys. Your first $10 of usage is free.Required

Tools this server provides (29)

Read directly from the server.

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 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
run
**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 ready global: `await bowmark.<capability>.<fn>(...)`, or one site via `await bowmark.providers.<provider>.<fn>
jig_open
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 ht
jig_list
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 })` inst
jig_search
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 `curs
jig_publish
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 — bla
jig_set_handle
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 hol
jig_get
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` onl
jig_update
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
jig_pull_update
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, ht
jig_read
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.
jig_look
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`):
session_call
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.`, spli
session_close
Ends a session `session_call` opened and frees what it held. Pass the `sessionId`. Closing one that is already closed is harmless.
report
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 wa
get_usage
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.
llm_poll
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.
llm_answer
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.
llm_detach
Detaches this chat at once, so open Bowmark pages' AI calls go back to Bowmark's own model instead of waiting for this chat.
support
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 usuall
list_secrets
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.secre
request_secret
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
get_secret_link
Return the dashboard link for one stored secret this account holds, so you can answer "where is my Acme password?" with somewhere to go. **It returns a URL, never a value** — opening it requires the user to be signed in and to confirm who they are, and only their own browser can read what comes back.
list_connections
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 alread
add_connection
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 exp
wait_for_sign_in
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 t
lease_ip
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 `priceC
delete_connection
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 comp
logout_connection
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

What it does

Typed site libraries
Per-site functions return structured data.
Actions as well as reads
Supports bookings and form actions.
Secret handling
Tools exist for requesting and listing secrets.
Usage-based billing
Charged by resources used; first $10 free.
No browser needed
Scripts run without a rendered browser session.

Good for

  • Search hotels and get structured results
  • Pull YouTube transcripts
  • Compare Amazon product listings
  • Check Calendly availability

Pricing

Freemium

First $10 of usage free, then pay for resources used

Prices change. Check bowmark.ai before you buy.

Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram FAQ

What is free?

The first $10 of usage and reading the library.

Do failed calls cost?

Yes, they are charged at the same rates for resources used.

How is it installed?

Via the bowmark-mcp PyPI package, an npm package, or a remote endpoint.

Is Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram free?

Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram has a free plan, with paid plans for more usage or features.

How do I add Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram to Claude Code?

Run this command in your terminal: claude mcp add --transport http bowmark https://api.bowmark.ai/mcp/registry

What are the best alternatives to Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram?

The closest alternatives to Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram are Browser Use, Scrapling MCP Server, HyperFrames by HeyGen, Firecrawl MCP Server and ffmpeg-skill.

Alternatives to Bowmark web data: LinkedIn, Amazon, YouTube, Reddit, Airbnb, Instagram

  1. Browser Use

    MCP server

    Browser agents and cloud browsers for AI, with an MCP server for web tasks

    • 7 tools
    • Remote
    • Freemium
    • 121K GitHub stars
    • Browser automation
  2. MCP server for AI clients to scrape sites with HTTP and stealth browser sessions

    Runs locally
    • 17 tools
    • Open source
    • 104K GitHub stars
    • Web search and scraping
  3. Hosted MCP connector for creating and rendering videos from HTML through AI chat

    • Remote
    • Freemium
    • 85.3K GitHub stars
    • Design and media
  4. MCP server that lets AI agents search, scrape and interact with web pages

    • 3 tools
    • Remote
    • Freemium
    • 7.8K GitHub stars
    • Web search and scraping
  5. ffmpeg-skill

    MCP server

    Local FFmpeg video and audio editing tools for coding agents over MCP

    Runs locally
    • Open source
    • 6.9K GitHub stars
    • Design and media
  6. SearXNG Search

    MCP server

    MCP server for web search and page reading through a SearXNG instance

    Runs locally
    • 3 tools
    • Open source
    • 1.4K GitHub stars
    • Web search and scraping