Skip to content
Back to search

unbrowse

MarketplaceWorks with Claude CodeGitHub

Unbrowse for Claude Code: the node's tools and the agent skills

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/unbrowse-ai-unbrowse/badge.svg)](/listings/unbrowse-ai-unbrowse)

HTML

<a href="/listings/unbrowse-ai-unbrowse"><img src="/api/listings/unbrowse-ai-unbrowse/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

You need Node 20.3 or newer, on macOS, Linux or Windows.

npm i -g unbrowse
unbrowse connect

`unbrowse connect` starts Unbrowse on your machine and adds it to Claude Code. Restart Claude Code and ask it to get something from a website. `unbrowse app` opens the window; `unbrowse start` runs the node without it.

Version 13 is on npm under the tag `next` for now: a plain `npm i -g unbrowse` still installs 12.5.0, the hosted client that has closed. For Codex, Cursor, VS Code, Gemini, Zed and other agents, see [Install the Unbrowse MCP](docs/install-mcp.md).

Prefer not to use npm?

- **macOS:** download the disk image from [Releases](https://github.com/unbrowse-ai/unbrowse/releases), open it and drag Unbrowse onto Applications. It is signed ad hoc, not notarized, so open it the first time by hand: right-click it and choose Open, or on macOS 15 and later, after the warning, System Settings > Privacy & Security > Open Anyway. - **Linux or Windows:** download `unbrowse-<version>-linux-<arch>.tar.gz` or `unbrowse-<version>-windows-x64.zip`. It holds the node, `unb`, the browser and the window in one folder, with a README that says how to start them. Check the download against the release's `SHA256SUMS`.

A release keeps itself up to date and runs on Arc testnet. npm fetches the programs for the machine it installs on: macOS (Apple silicon and Intel), Linux (x64 and arm64, glibc 2.35 or later) and Windows (x64). That brings the app, the node, `unb`, the agent skill and the client, and no browser: the node fetches its browser the first time a goal needs one (or `unbrowse browser install` fetches it now; [docs/guides/the-browser.md](docs/guides/the-browser.md)). Foundry's Anvil (`foundryup`) is needed only for test mode, the local devnet: the default of a build from source, or a node whose `chain` setting is `devnet`.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 16 lines
  1. {
  2. "name": "unbrowse",
  3. "description": "Unbrowse for Claude Code: the node's tools and the agent skills",
  4. "owner": {
  5. "name": "Unbrowse",
  6. "url": "https://unbrowse.ai"
  7. },
  8. "plugins": [
  9. {
  10. "name": "unbrowse",
  11. "source": "./integrations/claude-code",
  12. "description": "Use websites through the Unbrowse node on this machine: say what you want and get the site's own JSON back",
  13. "category": "development"
  14. }
  15. ]
  16. }
README.md · README · 335 lines
  1. # Unbrowse
  2. **Your agent uses websites without a browser.**
  3. Unbrowse runs on your own computer. The first time your agent needs something from a site, Unbrowse opens the page
  4. once, finds the request the site's own app makes, and keeps it. After that, your agent makes that request directly:
  5. plain HTTP, no browser, no page to read.
  6. On a site it has learned, Unbrowse is up to 100× faster than driving a browser. Across 94 sites, an uncached answer took
  7. 950 ms on average, against 3,404 ms for a browser agent ([research paper](https://arxiv.org/abs/2604.00694)). A cached
  8. answer comes back in about 67 ms.
  9. [Releases](https://github.com/unbrowse-ai/unbrowse/releases) ·
  10. [Install the MCP](docs/install-mcp.md) ·
  11. [Moving from the hosted version](docs/upgrade.md) ·
  12. [Architecture (AGENTS.md)](AGENTS.md) ·
  13. [Contributing](CONTRIBUTING.md) ·
  14. [Security](SECURITY.md)
  15. ## Install
  16. You need Node 20.3 or newer, on macOS, Linux or Windows.
  17. ```bash
  18. npm i -g unbrowse
  19. unbrowse connect
  20. ```
  21. `unbrowse connect` starts Unbrowse on your machine and adds it to Claude Code. Restart Claude Code and ask it to get
  22. something from a website. `unbrowse app` opens the window; `unbrowse start` runs the node without it.
  23. Version 13 is on npm under the tag `next` for now: a plain `npm i -g unbrowse` still installs 12.5.0, the hosted client
  24. that has closed. For Codex, Cursor, VS Code, Gemini, Zed and other agents, see [Install the Unbrowse MCP](docs/install-mcp.md).
  25. Prefer not to use npm?
  26. - **macOS:** download the disk image from [Releases](https://github.com/unbrowse-ai/unbrowse/releases), open it and drag
  27. Unbrowse onto Applications. It is signed ad hoc, not notarized, so open it the first time by hand: right-click it and
  28. choose Open, or on macOS 15 and later, after the warning, System Settings > Privacy & Security > Open Anyway.
  29. - **Linux or Windows:** download `unbrowse-<version>-linux-<arch>.tar.gz` or `unbrowse-<version>-windows-x64.zip`. It holds
  30. the node, `unb`, the browser and the window in one folder, with a README that says how to start them. Check the
  31. download against the release's `SHA256SUMS`.
  32. A release keeps itself up to date and runs on Arc testnet. npm fetches the programs for the machine it installs on:
  33. macOS (Apple silicon and Intel), Linux (x64 and arm64, glibc 2.35 or later) and Windows (x64). That brings the app, the
  34. node, `unb`, the agent skill and the client, and no browser: the node fetches its browser the first time a goal needs
  35. one (or `unbrowse browser install` fetches it now; [docs/guides/the-browser.md](docs/guides/the-browser.md)).
  36. Foundry's Anvil (`foundryup`) is needed only for test mode, the local devnet: the default of a build from source, or a
  37. node whose `chain` setting is `devnet`.
  38. ## Used the hosted version?
  39. Unbrowse used to run on our servers. That service closed in November 2026. An old agent setup that still points at it hears the two
  40. commands above in reply. If you set Unbrowse up with version 12 or earlier, run them. `unbrowse connect` finds your old
  41. setup, asks before changing it, keeps a copy, and can undo the move. Logins you saved on the hosted service did not move
  42. to your machine; [Moving to the new Unbrowse](docs/upgrade.md) says how to add the ones you need.
  43. ## How it works
  44. A **route** is one learned call: the request, every value it needs traced to where it comes from, and the caller's
  45. values as inputs. An agent says what it wants; the node calls the route that does it, or learns one and calls that.
  46. ```
  47. agent ── HTTP / MCP ──▶ unbrowse-node ──▶ the site's own API (a route, plain HTTP)
  48. │
  49. └── links unbrowse-browser/core ──▶ Chrome (once, to learn the route)
  50. ```
  51. Your sign-ins stay on your computer, in your system's own keystore.
  52. ## Choose a starting point
  53. | Goal | Start here |
  54. |---|---|
  55. | Use it | [Install](#install) |
  56. | Connect an agent (Claude Code, Cursor, …) | [Install the Unbrowse MCP](docs/install-mcp.md), or [Connect an agent](#connect-an-agent) |
  57. | Move from the hosted version | [docs/upgrade.md](docs/upgrade.md) |
  58. | Build from this repo | [Run from source](#run-from-source) |
  59. | Change the code | The [repository map](#whats-here), then the `README.md` in the directory you are touching |
  60. | Understand the idea | [docs/concepts/](docs/concepts/why-unbrowse.md): the concepts in plain words, from the papers, each ending with what the code does today and where it differs |
  61. | Read the design | [papers/](papers/README.md): the whitepaper, the economy, selection and the protocol specification, which is normative for the design |
  62. | Understand how it works | [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md): the whole system with diagrams — pipeline, keys, peer network, payments; [AGENTS.md](AGENTS.md) for the pattern and rules |
  63. | Know what it costs, and where fees go | [docs/MONEY.md](docs/MONEY.md): what each action costs, measured; the fee split; paying your own way |
  64. | Start as a new owner, from install to first earnings | [docs/ONBOARDING.md](docs/ONBOARDING.md); every command in [docs/CLI.md](docs/CLI.md); all the docs, and the order to read them, in [docs/README.md](docs/README.md) |
  65. | Fix something that broke | [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md): symptom, cause, fix |
  66. | Contribute | [CONTRIBUTING.md](CONTRIBUTING.md); report vulnerabilities privately per [SECURITY.md](SECURITY.md) |
  67. ## Run from source
  68. The node runs on macOS, Linux and Windows. Its root key lives in the system's keystore (the Keychain, Windows'
  69. Credential Manager, or the Secret Service on Linux; on a Linux machine with no desktop session,
  70. `~/.unbrowse/root.key`, readable by its user alone). The node browses in Chrome or any other Chromium browser on the
  71. machine, and downloads Chrome for Testing the first time a goal needs a browser and there's none.
  72. Toolchain, the versions CI pins ([.github/workflows/ci.yml](.github/workflows/ci.yml)):
  73. | Tool | Version | For |
  74. |---|---|---|
  75. | Rust | stable | the node, `unb`, the browser |
  76. | [Foundry](https://getfoundry.sh) (`anvil`) | latest (`foundryup`) | test mode, the node's local payment chain |
  77. | Zig | 0.17.0 | the window |
  78. | Bun | 1.4.3 | the browser dashboard's tests |
  79. | Node | 22 | the TypeScript SDK and skill |
  80. ```bash
  81. # The browser the node drives (its own build and tests: unbrowse-browser/)
  82. cargo build --release --manifest-path unbrowse-browser/cli/Cargo.toml
  83. # The node. Its TLS stack is BoringSSL patched to match Chrome's handshake, vendored once by a script
  84. cd unbrowse-node
  85. sh scripts/apply-tls-patch.sh
  86. cargo run --bin unbrowse-node
  87. # The window, in another terminal (it starts the node itself if nothing answers)
  88. cd unbrowse-node/window && zig build run
  89. ```
  90. The node listens on `127.0.0.1:7788` and keeps everything under `~/.unbrowse` (`UNBROWSE_HOME` moves it).
  91. A release install puts **one command, `unbrowse`**, on `PATH`: it runs the node and forwards the node's own commands to
  92. it (`unbrowse vault …`, `unbrowse agent …`, `unbrowse passkey …`, `unbrowse session …`, `unbrowse telemetry …`), and an
  93. agent's `do`/`browse`/`search`/`connect` to `unb`.
  94. ```bash
  95. unbrowse agent new my-agent # an agent key; prints its setup once
  96. unbrowse vault import export.csv # a browser's or password manager's login export
  97. unbrowse session import github.com # a site's signed-in session (add --from cookies.txt for an exported file)
  98. unbrowse passkey import keys.json # passkeys a password manager exported
  99. ```
  100. From this source build there is no `unbrowse` wrapper (it ships in the `unbrowse` npm package): run the binaries the build
  101. left at `target/release/` — `unbrowse-node <command>` and `unb <command>`. Each directory has its own build and tests;
  102. [unbrowse-node/README.md](unbrowse-node/README.md) is the one to read next, and lists every node command.
  103. ## Connect an agent
  104. On a fresh machine, `npm i -g unbrowse && unbrowse connect` is enough for Claude Code: `connect` starts the node if
  105. it isn't running and registers the agent the node made on its first run. For another agent, make a key (in the
  106. window: Money, Add agent; or `unbrowse agent new <name>`), then point an MCP client at the node with the key's
  107. token:
  108. ```bash
  109. # Claude Code
  110. claude mcp add --scope user unbrowse --env UNBROWSE_NODE=http://127.0.0.1:7788 -- unb mcp --agent first # unb mcp signs each request with the token, which never goes over the wire
  111. # Any other MCP client, or the CLI
  112. export UNBROWSE_NODE=http://127.0.0.1:7788
  113. export UNBROWSE_AGENT_TOKEN="$(unbrowse agent token)"
  114. unbrowse connect # starts the node if needed, registers your first agent with Claude Code
  115. ```
  116. Claude Code, Codex, OpenClaw, Hermes Agent and ElizaOS also take the node as a plugin, with the skill:
  117. [integrations/](integrations/README.md).
  118. The node serves MCP at `POST /mcp` and the same actions over HTTP on `127.0.0.1:7788`
  119. ([unbrowse-node/README.md](unbrowse-node/README.md#the-agent-api)). A global `npm install` also puts the agent skill in
  120. `~/.claude/skills/unbrowse`.
  121. Some routes belong to other people's nodes and carry a fee, paid from the node's balance in dollars; what each action costs, and where the money goes, is in [docs/MONEY.md](docs/MONEY.md). `unbrowse money` prints the balance, each agent's daily limit and earnings.
  122. ## What's here
  123. A polyglot repository, not a single-language monorepo. Each directory is its own build with its own `README.md` —
  124. **read the nearest one before changing the code there.**
  125. | Directory | What it is | Language | Guide |
  126. |---|---|---|---|
  127. | [`unbrowse-node/`](unbrowse-node) | The node: the agent API (HTTP and MCP on 127.0.0.1), the route learner, the vault, payments, and the window | Rust, Zig, TypeScript | [README](unbrowse-node/README.md) |
  128. | [`unbrowse-browser/`](unbrowse-browser) | The browser the node learns from: a fork of agent-browser that records every request and typed value | Rust | [AGENTS](unbrowse-browser/AGENTS.md) |
  129. | [`unbrowse-sdk/`](unbrowse-sdk) | `unbrowse` for npm and PyPI: the node, its browser, the agent skill and the client in one package | TypeScript, Python | [README](unbrowse-sdk/README.md) |
  130. | `unbrowse-settlement/` (private repository) | The settlement contracts that pay contributors, sites and the network for each call | Solidity | private |
  131. | [`unbrowse-telemetry/`](unbrowse-telemetry) | The worker that takes nodes' anonymous usage events ([what is sent](#usage-telemetry)) | JavaScript | [README](unbrowse-telemetry/README.md) |
  132. | [`skills/`](skills) | Agent skills that teach an agent to use the node | Markdown | [README](skills/README.md) |
  133. | [`integrations/`](integrations) | The node as a plugin for Claude Code, Codex, OpenClaw, Hermes Agent and ElizaOS | TypeScript, Python | [README](integrations/README.md) |
  134. | [`papers/`](papers) | The design: the whitepaper, the economy, selection and the protocol specification, as Markdown and PDF | Markdown, PDF | [README](papers/README.md) |
  135. | [`docs/`](docs) | The docs: concepts, getting started, guides, reference, and the system docs | Markdown | [README](docs/README.md) |
  136. The architecture, with diagrams of the pipeline, keys, peer network and payments, is in
  137. [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md); what each action costs and where the money goes is in
  138. [docs/MONEY.md](docs/MONEY.md). The two repository-wide guides sit at the root: [AGENTS.md](AGENTS.md) explains the pipeline and the rules learned
  139. building it; [CLAUDE.md](CLAUDE.md) adds the one rule every change follows — fixes are general, never written for one
  140. site. CI runs every directory's tests ([.github/workflows/ci.yml](.github/workflows/ci.yml)); work lands on `staging`,
  141. is cut into `release/X.Y` branches and ships to `main` as tagged semantic versions
  142. ([CONTRIBUTING.md](CONTRIBUTING.md#branches-and-releases)).
  143. ## Usage telemetry
  144. The node tells Unbrowse how it is used, so we can show the network is used and fix what breaks. It is on by default
  145. in a release while the node is on the network (a node you keep off the network sends nothing; a build from source sends nothing
  146. unless `UNBROWSE_TELEMETRY=1`), it says so when it starts, and one command turns it off:
  147. ```bash
  148. unbrowse-node telemetry off # kept in ~/.unbrowse/telemetry.json; `unbrowse-node telemetry` shows the state
  149. UNBROWSE_TELEMETRY=0 # in the environment: off, whatever the file says
  150. ```
  151. **What is sent**, in batches to `telemetry.unbrowse.ai` ([`unbrowse-telemetry/`](unbrowse-telemetry)), and nothing else:
  152. | Field | What it is |
  153. |---|---|
  154. | `event` | `node_start` (the node started), `tool_call` (an agent called a tool), `route_failed` (a route the node keeps ran and failed) or `fetch_failed` (a paid fetch of another node's route failed) |
  155. | `version`, `os` | the node's version, and `macos`, `linux` or `windows` |
  156. | `install_id` | a random id drawn once for this install, tied to nothing else: not your identity, account, machine or name |
  157. | `tool` | which agent tool or API route: `unbrowse_do`, `unbrowse_call`, `/v1/routes/{id}/call`, … (never which route) |
  158. | `outcome`, `error_class` | `ok`, `failed` (the site's call failed) or `error` (the node refused it), and a coarse class: `not_found`, `forbidden`, `site`, …; for a failed route or fetch, the kind of failure from a fixed list (`http`, `door`, `shape_mismatch`, `no_body`, …) |
  159. | `duration_ms` | how long the call took |
  160. **Never sent:** URLs, sites or host names, page content, requests or answers, route ids, goals or inputs, cookies,
  161. passwords, passkeys, vault entries, keys, wallet addresses, user or machine names, or your IP address. Every field and
  162. value is checked against a fixed list before it is queued, and again by the worker, which refuses a batch with any
  163. other field or anything that looks like an address. The worker keeps each event and the hour it arrived; it never
  164. reads or keeps the caller's IP address.
  165. **Your linked wallet.** Unbrowse uses no API keys, and needs no account: the node has its own wallet. If you link a
  166. wallet of yours to the node (with email or Google, or your own), the node also sends the site three events while telemetry is on: `node_started`, `owner_linked` and
  167. `owner_unlinked`. Each is signed by the node's key and names the node's address and your account's address, so a
  168. count belongs to a node that really sent it and the account that owns it (`unbrowse-node/app/src/link.rs`,
  169. `link::tell`). They never name a site, route or input. A node you haven't linked sends none, and `telemetry off`
  170. stops them too. The usage counts above stay as they are: no account, only the random install id.
  171. Telemetry never slows the node: an event is queued without waiting, a full queue drops it, and a batch the worker
  172. doesn't take within a few seconds is dropped, never retried. With the worker down, everything works the same.
  173. ## Bug reports
  174. Agents notice what the node can't: a result for another repository than the one asked for, a block page answered as
  175. `ok: true`, a call that only worked with a workaround. So an agent reports it, with `unbrowse_report` (MCP),
  176. `POST /v1/report`, `unb report` or `report()` in the SDKs, and carries on. The node scrubs the report, adds what it
  177. knows, and sends it to the relay at `telemetry.unbrowse.ai` ([`unbrowse-telemetry/`](unbrowse-telemetry)), which files
  178. it as a **public issue** on [unbrowse-ai/unbrowse](https://github.com/unbrowse-ai/unbrowse/issues) labelled
  179. `agent-report`. Reports of the same problem share one issue, which counts them: the same kind, tool, route shape,
  180. page host and last failed call, as the node says them (an agent's own words never split or join problems). A problem
  181. whose issue was closed opens a new one. The node also reports a few problems it notices itself: a crash, an internal error, a route that still failed
  182. after its page was walked again.
  183. Reports are off until you turn them on (`unbrowse-node reports on`), since each becomes a public issue. Once on, they
  184. follow telemetry: off in a build from source unless `UNBROWSE_REPORTS=1`, and off whenever telemetry is.
  185. **An agent's report waits for you.** An agent writes its own words into a report, and a page it read can steer what it
  186. writes, so nothing an agent reports leaves until you have read it, scrubbed, in your window and sent it
  187. (`reports_waiting`, then `report_send`, which the node asks you about in its own dialog with the report's text shown,
  188. or `report_discard`). The agent is told its report waits (`waiting_for_owner`). Reports the node makes itself carry no
  189. words from a site, and are sent as before.
  190. ```bash
  191. unbrowse-node reports on # opt in; `reports off` turns them off again
  192. unbrowse-node reports off # kept in ~/.unbrowse/reports.json, and a running node stops at once; `unbrowse-node reports` shows the state
  193. UNBROWSE_REPORTS=0 # in the environment: off, whatever the file says
  194. ```
  195. **What a report holds**, and nothing else (the relay refuses any other field):
  196. | Field | What it is |
  197. |---|---|
  198. | `kind` | `wrong_data`, `false_success`, `failed`, `slow`, `confusing` or `other` |
  199. | `summary`, `expected`, `got`, `goal`, `error` | the agent's words, scrubbed and cut to 140 to 1,500 characters |
  200. | `url` | the page's scheme, site and path template (below); never its query or fragment |
  201. | `tool` | which agent tool gave the wrong answer |
  202. | `route` | the route's shape: method, site, path template, input names, whether it writes, its step count |
  203. | `last_error` | the agent's last failed call in the past ten minutes: its tool, class, and the status or kind of error the node saw (`Failed: step 2 of 2 answered 403`); never what the site said |
  204. | `version`, `os`, `source` | the node's version and OS, and whether an agent or the node filed it |
  205. | `install_id` | for the relay's limit of 20 reports an install a day; never published, kept only hashed with the day |
  206. **Scrubbed before it leaves**, then again by the relay, after decoding what is encoded (`%40`, `\/`, `&#64;`) and
  207. dropping hidden characters (zero-width, bidi): query strings and fragments, logins in URLs, emails, IP addresses,
  208. numbers of nine digits or more however they are spaced (cards, phone numbers, national ids; four or more in a path),
  209. hex, tokens and keys, the value of any field whose name says it's a secret (`password=`, `"api_key": …`, `code:`),
  210. vault references, your home folder, user name, machine name and vault account names. A host keeps only the site's
  211. own name: the names in front of it are `*` (`*.atlassian.net`), a machine on your network is `[internal]`, an
  212. address `[ip]`. A route's or page's path keeps only plain lowercase words, templates and versions; anything else (a
  213. handle, an id, a file name) is `{id}`. A route's input values and defaults, cookies, headers and bodies are never
  214. read into a report, and nor is anything a site said: the node's own reports and `last_error` carry only the error's
  215. kind and status. A report says which site the agent was using, never whose account.
  216. The reply tells the agent what happened (`sent` with the issue's URL, `queued` while the relay can't be reached,
  217. `already_sent` for a problem this node reported today, or `off`), what was scrubbed, and the report exactly as filed.
  218. A queued report is sent within the next quarter hour, for up to a week.
  219. ## When a page needs you
  220. The node gets past a site's defenses itself wherever it can, and says so plainly: a challenge, a bot check or a
  221. clearance cookie is a step to satisfy, not a stop sign. A check an agent can see — an image grid, a slider, a queued
  222. page — is met with `unbrowse_challenge`: the node shows the agent a picture of the page and takes its clicks one step
  223. at a time, so the agent's own model reads the check and the page's own answer says whether it passed. Some pages only a
  224. person can get past: a sign-in your vault has no login for, a two-step code, a check that renders only for a human.
  225. An agent asks with `unbrowse_browse ["ask_owner", "sign in to LinkedIn"]`, and the app's **Browser** screen shows you
  226. that page live: click and type on the picture as if it were the page, then press **Done, give it back**. You can open Browser any time without
  227. being asked. Agents never see what you type, and the session stays in the site's profile, so the agent carries on signed
  228. in ([unbrowse-node/README.md](unbrowse-node/README.md#the-owners-hands-on-a-page)).
  229. A wall the node cannot clear is reported as `blocked`, never as data. Bypassing anti-bot is part of the product, done
  230. openly; faking a success the site did not give is not.
  231. ## Website passkeys (on by default)
  232. A headless browser has no authenticator, so a site that asks for a passkey ("verify it's you") stops an agent until a
  233. person acts. The node keeps a site's passkey in its vault and answers that prompt itself. **This is on by default.**
  234. When **you** sign in on a page by hand (you take it over when the agent asks, and give it back done) and the site then
  235. offers to make a passkey (its "add a passkey?" prompt after sign-in, or one it makes on its own), the node accepts it
  236. and keeps it, with no further step from you. A vault login an *agent* fills arms nothing: a passkey signs in as you
  237. with no password and no second factor, so one an agent could make would be a credential stronger than its own key —
  238. and every key on the node as strong as the weakest of them. A site
  239. that never offers one gets none: the node doesn't go into a site's settings to make one. The passkey is sealed in the
  240. vault under a key derived from the root key, and it never goes to the network, a peer or a log. The node says so the
  241. first time it starts, and `unbrowse-node passkey list` shows every passkey it holds and whether it was enrolled
  242. automatically (`auto`) or by you (`manual`). A passkey a password manager exported (Bitwarden, CXF, KeePassXC) can
  243. be imported too (`unbrowse passkey import <file>`); iCloud Keychain, Google Password Manager, Windows Hello and security
  244. keys don't let one out.
  245. **The risk, plainly: any site the node signs in to may get a passkey registered on your account, and whoever
  246. controls your node can then sign in as you there.** That includes any agent holding one of its keys, since agents
  247. drive the node's browser and the node answers the passkey prompt for them, with no prompt to you and no second
  248. factor: the passkey is the second factor. A Google (Gmail) account is the highest-value target there is: it resets
  249. the passwords of most of your other accounts, so a node holding its passkey can reach them too. Keep the node on a
  250. machine you alone control, and check the activity log (every enrolment and every sign-in with a stored passkey is a
  251. line there).
  252. **To opt out:** `unbrowse-node passkey off` (or `UNBROWSE_PASSKEYS=0`) for every site, or `unbrowse-node passkey never
  253. <site>` for one (`passkey allow <site>` undoes it); `passkey never google.com` is the one to consider first. To delete
  254. a passkey: `unbrowse-node passkey remove <id>`, then on the site's account page (security, passkeys) delete it there
  255. too, or the site keeps accepting it; on Google that is `https://myaccount.google.com/signinoptions/passkeys`. More:
  256. [unbrowse-node/README.md](unbrowse-node/README.md#website-passkeys-on-by-default).
  257. ## Contributing and security
  258. See [CONTRIBUTING.md](CONTRIBUTING.md). Report vulnerabilities privately, as [SECURITY.md](SECURITY.md) describes,
  259. never in a public issue.
  260. ## Licence
  261. [Apache-2.0](LICENSE). Copies and forks keep the [NOTICE](NOTICE) file. The licence covers the code, not the name:
  262. a fork ships under its own name ([TRADEMARKS.md](TRADEMARKS.md)).
  263. Third-party code keeps its own licence: agent-browser (Apache-2.0) in `unbrowse-browser/`; forge-std (MIT or
  264. Apache-2.0) and OpenZeppelin (MIT) in `unbrowse-settlement/lib/`.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.