parchi is a free, open source browsers & extensions project written in TypeScript and released under MIT. It has 546 GitHub stars, 57 forks and 11 open issues, and was last pushed 4 days ago. On this registry it ranks #147 of 150 tracked projects in Browsers & Extensions, with 5 head-to-head comparisons available.

What is parchi?

Parchi is a free, MIT-licensed AI browser copilot — a Chrome MV3 and Firefox 109+ extension written in TypeScript that puts chat-driven browser automation in a side panel, built for people who want to navigate, read, click, type, extract, and summarize pages under their own model configuration.

What it is

Parchi lives in the browser-extension ecosystem as an add-on for Chrome (Manifest V3) and Firefox 109 and later. A streaming chat panel sits beside the page and drives a set of browser tools: navigate, read, interact, tabs, and screenshots. The project is deliberately model-agnostic, so the same panel can point at OpenAI at https://api.openai.com/v1, an Anthropic-compatible endpoint, OpenRouter at https://openrouter.ai/api/v1, a local runtime such as Ollama or LM Studio at http://localhost:11434/v1, or any other OpenAI-compatible endpoint. The source is a TypeScript monorepo split into packages/extension for the runtime, UI, and tools, packages/backend for a Convex backend handling auth, billing, and proxying, and packages/shared for schemas, prompts, and runtime types, with scripts/ and tests/ alongside.

The concrete problem it solves is the gap between what a user reads in a tab and what an assistant can act on. Instead of copying text out of a page into a chat window, writing throwaway bookmarklets, or pasting ad-hoc scripts per site, the agent operates in the same tab context under explicit tool permissions and a domain allowlist. It also removes the need to accept whichever cloud copilot a vendor ships with the browser, because a user profile can be repointed at a different provider, or at a local model, without changing the extension.

Key capabilities

  • Streaming chat paired with a tool execution timeline, so each model action is visible as it runs.
  • Browser tools covering navigate, read, interact, tabs, and screenshots.
  • Profile-based model and provider configuration with API key, endpoint or base URL, model ID, and optional custom headers.
  • An orchestrator plus subagent flow for multi-step tasks.
  • Session history with exports.
  • Tool permissions and domain allowlist controls for restricting what the agent may touch.
  • Separate build targets: npm run build produces the Chrome bundle in dist/, and npm run build:firefox produces the Firefox bundle in dist-firefox/.

Who uses it and how

  • Chrome users build the extension, enable Developer mode, and load the unpacked dist/ directory from chrome://extensions; Firefox users load dist-firefox/ through about:debugging.
  • Cost- or privacy-sensitive users point a profile at a local Ollama or LM Studio endpoint on http://localhost:11434/v1 so page content and prompts stay on their own machine.
  • Automation-oriented users lean on the browser-automation and workflow topics, running repeated read, extract, and summarize loops from the side panel rather than by hand.
  • Contributors work against the harnesses in tests/, running npm run test:unit, npm run test:integration, and npm run test:e2e, along with the orchestrator and performance harnesses.

Getting started

Build from source: git clone the repository, run npm install, then npm run build, and load the resulting dist/ folder as an unpacked extension; Firefox builds with npm run build:firefox and loads from about:debugging. The project also lists a homepage at https://parchi.ai.

How it compares

The facts provided name no paid products that Parchi replaces and no directly comparable tools, so it stands alone in this registry rather than being positioned against a named commercial alternative. Its distinguishing axis, as documented, is model-agnostic configuration inside a browser extension under an MIT licence, with no stated vendor lock-in to an endpoint.

When to use it — and when not to

Parchi suits users willing to build from source, supply an API key or run a local model, and accept the safety notice, since browser automation can violate a site's terms of service and prompt injection can trigger unsafe actions if untrusted prompts or pages are involved. Anyone who runs packages/backend takes on operating a Convex backend for auth, billing, and proxying. It is a poor fit for people who want a managed, zero-configuration copilot, and the current state shows a modest 546 stars, 54 forks, and 11 open issues, so it is best treated as a self-hosted tool for hands-on users rather than a polished consumer product.

project readme (upstream, from github) — read inline

Parchi

AI-powered browser copilot (Chrome/Firefox extension).

Chat-driven browser automation in a side panel: navigate, read, click, type, extract, and summarize.

Chrome MV3 Firefox License: MIT


⚠️ Safety Notice

Browser automation can perform sensitive actions on your behalf. Use this tool only if you understand and accept the risks:

  • automation may violate site terms of service
  • prompt-injection can cause unsafe actions
  • sensitive information can be exposed if you run untrusted prompts/pages

Always review model output and keep strict tool/domain controls enabled when needed.


📦 Installation

Chrome (recommended)

git clone https://github.com/0xSero/parchi.git
cd parchi
npm install
npm run build

Then:

  1. Open chrome://extensions
  2. Enable Developer mode
  3. Click Load unpacked
  4. Select dist/

Firefox

npm run build:firefox

Then load the generated extension from dist-firefox/ in about:debugging.


🔧 Configure a Model

Open the extension settings and configure an OpenAI-compatible provider:

  • OpenAI https://api.openai.com/v1
  • Anthropic-compatible
  • OpenRouter https://openrouter.ai/api/v1
  • Local (Ollama/LM Studio) http://localhost:11434/v1
  • any other OpenAI-compatible endpoint

You can set:

  • API key
  • endpoint/base URL
  • model ID
  • optional custom headers

✨ Core Features

  • streaming chat + tool execution timeline
  • browser tools (navigate, read, interact, tabs, screenshots)
  • profile-based model/provider configuration
  • orchestrator + subagent flow
  • session history and exports
  • tool permissions and domain allowlist controls

🏗 Repo Structure

Path Purpose
packages/extension/ Browser extension runtime + UI + tools
packages/backend/ Convex backend (auth/billing/proxy)
packages/shared/ Shared schemas, prompts, runtime types
scripts/ Build/release/check scripts
tests/ Unit/integration/e2e/orchestrator/perf harnesses

🔨 Development

npm install
npm run build
npm run typecheck
npm run lint
npm run test:unit
npm run test:integration
npm run test:e2e
npm run check:repo-standards

If you change sidepanel UI code, rebuild and reload the extension from dist/.


📄 License

MIT

Frequently asked questions

Is parchi free to use?

parchi is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does parchi do?

Your AI friend right in your browser

What is parchi written in?

parchi is primarily written in TypeScript. Its source is publicly available at https://github.com/0xSero/parchi, and it has 546 GitHub stars.