Summarize: A CLI and Browser Extension for Turning Any Link into a Summary

What Problem Does Summarize Solve?

The problem is simple: you have a link, a file, or a media item, and you want the gist without reading or watching the whole thing. Summarize targets developers, researchers, and content consumers who work across many formats. The README's tagline, 'Link in, signal out,' captures the core value. It is for anyone who needs to quickly process a web page, a PDF, a YouTube video, or a podcast episode into a concise summary. The tool is not a full content management system; it is a focused extraction and summarization utility. It is particularly useful for those who want to keep their data local or control their own model providers, as opposed to relying on a closed web service.

How It Works: Extraction, Transcription, and Model Backends

Summarize uses a multi-stage pipeline. For web pages, it applies Readability extraction to pull the main content, with optional Markdown conversion and a Firecrawl fallback if the primary extraction fails. For media, it first looks for published transcripts or captions, which avoids unnecessary transcription. If none exist, it falls back to local or cloud transcription, with optional speaker labels. For video slides, it extracts scene-based frames, optionally runs OCR, and produces timestamped output. The summary generation itself is delegated to a model provider. The default 'auto' model picks among configured providers. You can use API-based providers, OpenAI-compatible endpoints, Ollama, OpenRouter free models, or authenticated coding CLIs like Codex, Claude, Gemini, OpenClaw, and GitHub Copilot. This design separates content extraction from summarization, allowing you to mix and match. The README shows a simple example: `summarize "https://example.com" --extract --plain` returns clean text without any API key, proving that extraction is independent of model calls.

Getting Started: Commands and Configuration

You can run Summarize without installing it globally: `npx -y @steipete/summarize --version`. For persistent use, install via npm (`npm install --global @steipete/summarize`) or Homebrew (`brew install summarize`). The npm package requires Node.js 24 or newer, but Homebrew and macOS archives provide standalone builds. The quick start for a model-generated summary is `summarize "https://example.com" --cli codex`, which uses an authenticated coding CLI. Configuration lives at `~/.summarize/config.json`, and command-line flags take precedence. To inspect the effective setup without exposing keys, run `summarize status`. For automation, `--json` provides a stable envelope. The README mentions a five-minute quickstart that covers API keys, local models, files, YouTube, podcasts, and JSON output. The extension can pair with the CLI via `summarize daemon install --token <TOKEN>`, which enables native media tools and shared caches.

Media Handling: Transcripts First, Then Transcriptions

A notable design choice is that Summarize prefers existing captions and podcast transcripts before transcribing media. This saves time and cost. If no transcript exists, it falls back to transcription. The tool supports native `ffmpeg`, `yt-dlp`, and `tesseract` to extend codec, YouTube slide, and OCR support. There is also a bundled WebAssembly FFmpeg path that covers common media without a native install. This is a practical trade-off: the WebAssembly path is convenient but likely limited in codec support compared to a full ffmpeg install. The README suggests that for advanced media, you should install the native tools. This means the tool can work out of the box for basic audio and video, but you may need to install additional dependencies for exotic formats. The documentation includes separate guides for YouTube, media routing, slides, and local ONNX transcription, indicating that media is a first-class concern.

The Browser Extension: Side Panel and Daemon Mode

The Chrome Side Panel and Firefox Sidebar extension lets you summarize the active tab, chat with its content, and work with video transcripts and slides. It has a 'direct mode' that runs without a companion service, using Chrome's capabilities for local transcription and slide extraction. For more advanced features, you can install a daemon that pairs with the CLI. The daemon adds CLI model backends, native media tools, OCR, shared caches, and Firefox media support. The setup involves copying a token from the extension and running `summarize daemon install --token <TOKEN>`. This two-tier approach is interesting: the extension works standalone for basic needs, but the daemon unlocks the full CLI power. The README points to a dedicated architecture and troubleshooting guide for the extension, which suggests that the pairing process can have edge cases. The extension is distributed through the Chrome Web Store, so installation is straightforward for Chrome users.

Limitations and Trade-offs

The most obvious limitation is the Node.js 24 requirement for the npm package. If you are on an older Node LTS, you cannot use the npm install path; you must rely on Homebrew or standalone builds. Another limitation is the dependency on external model providers. The extraction step works without an API key, but summaries require a configured provider or a coding CLI. If you have no provider, you only get extraction. The README mentions Firecrawl as a fallback, but Firecrawl is a separate service that likely requires an API key or account. For media, the reliance on transcripts first means that if a video has no captions and you do not have native transcription tools installed, the quality may suffer. The WebAssembly FFmpeg is a fallback, but it is not a full replacement for native ffmpeg. Also, the project is actively developed with frequent releases (v0.21.11, v0.21.10, v0.21.9 within days), which means the CLI surface may change. You should pin your version or check the changelog before upgrading.

Alternatives and How They Differ

A direct alternative is Mozilla's Readability.js, which is a library that extracts readable content from web pages. Readability.js only handles web pages, not media or podcasts, and it does not generate summaries. Summarize builds on Readability but adds transcription, model integration, and a CLI. Another alternative is a hosted service like Notion AI or ChatGPT with browsing, which can summarize URLs but typically requires a subscription and sends your content to a cloud service. Summarize's approach is different because it offers local extraction and the option to use local models like Ollama, keeping data on your machine. There is also `yt-dlp` for downloading YouTube videos and extracting subtitles, but it does not produce summaries. Summarize uses `yt-dlp` as a fallback for YouTube slide extraction, but it integrates that into a single workflow. The key difference is that Summarize combines extraction, transcription, and summarization into one tool, whereas alternatives tend to focus on one stage.

Maintenance, Upgrade Cost, and License

The project is under active maintenance, with multiple releases in a single week. The repository is not archived, and the default branch is main. This is a positive sign for bug fixes, but it also means you should expect frequent updates. The upgrade cost is moderate: since it is a CLI tool, you can update via npm or Homebrew. However, the configuration schema in `~/.summarize/config.json` could change between minor versions, so you should review the changelog or run `summarize status` after upgrading. The library package `@steipete/summarize-core` is available for programmatic extraction, which is useful if you want to integrate extraction into your own application without the full CLI dependency surface. The license is MIT, which allows commercial use, modification, and redistribution with attribution. There are no obvious copyleft restrictions, but you should read the LICENSE file for full terms. The README mentions a contribution guide and development setup with pnpm, which is standard for a TypeScript project.

Editorial conclusion

Adopt Summarize if you need a single tool to pull clean text and summaries from web pages, YouTube, podcasts, and local files, and you are comfortable with Node.js 24 or a Homebrew install. Avoid it if you require a fully managed SaaS with zero local configuration, or if your media files rely on exotic codecs that neither ffmpeg nor the WebAssembly fallback can handle. Before committing, verify that your preferred model provider is supported, check the configuration schema in docs/config.md, and test the --extract mode on a few representative URLs to confirm the readability extraction meets your quality bar. The project is actively maintained with frequent releases, so check the changelog for breaking changes if you upgrade between minor versions.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes