SerpApi has published an open-source plugin that gives the OpenCode coding agent the ability to run live web searches, according to the company's own announcement on dev.to and the project's GitHub repository. OpenCode is described in that material as an open-source, model-agnostic AI coding agent that runs locally, edits files, runs terminal commands and works across multiple repositories. The plugin's stated purpose is to fill a gap the announcement identifies: without added tooling, OpenCode cannot search the web for live data.
The plugin is distributed as an npm package named opencode-serpapi. Setup, as documented, is a configuration change plus a credential rather than a separate install step. Users add the package to a plugin array in opencode.json at the project root, or to the global config at ~/.config/opencode/opencode.json to make it available across projects. OpenCode installs npm plugins automatically at startup, so no separate npm install command is required. The repository notes that the package supports both plugin interfaces from one entrypoint, with V1 using server() and V2 using setup(), and that the configuration key differs by version: plugins on OpenCode 2 and plugin on OpenCode 1.
Authentication runs through an environment variable. Users obtain a key from the SerpApi dashboard and export it as SERPAPI_API_KEY. The repository states that the key is read from the OpenCode process and resolved into an MCP Authorization: Bearer header, and that it is not embedded in the MCP URL or in source code. On startup, per the announcement, OpenCode caches the plugin and registers a serpapi_search tool for the session.
Three components are described by the announcement, under the hood. The first: without any manual addition by the user, SerpApi's hosted MCP server at https://mcp.serpapi.com/mcp is automatically registered as a remote server by the plugin. The second: should that MCP server be disabled or unavailable, a native serpapi_search tool, relying on the runtime's built-in fetch and requiring no CLI, shell or cURL dependency, calls https://serpapi.com/search.json directly. The third: routing guidance and engine reference files are supplied by a bundled skill named serpapi-web-search, enabling the model to select an appropriate engine and parameters.
Further detail on how the native fallback deals with engine differences appears in the repository. The tool accepts one generic q argument, which gets mapped to whatever field a given engine expects; among the cited examples are k for Amazon, query for Walmart, _nkw for eBay, and search_query for YouTube. Engines outside that query-field map still pass through when q is used. The repository further states that a user-defined mcp.serpapi configuration already in place is preserved instead of being overwritten.
The engine coverage is broad by the project's own description. The repository lists Google, Amazon, Walmart, eBay, YouTube, Google Maps and Google Scholar among the supported engines, and says the MCP server covers 100+ engines in total. The announcement names Google, Bing, Yahoo, YouTube and Amazon among the accessible engines and says the plugin provides dedicated access to specific engines and verticals rather than only generic web search. It gives the example that an Amazon query returns product listings and pricing as structured JSON.
The announcement draws a distinction between plugins and skills that is relevant to how this package is built. In its framing, skills automate repeated workflows, while plugins add a capability the agent did not previously have, such as a new tool or an outside service integration. The SerpApi package ships both: the plugin supplies the connection and tool, and the bundled skill supplies the judgment about which engine and parameters fit a given query. The announcement argues that without the skill, a product query might fall back to a generic Google search and return blog posts and ads instead of listings.
Response handling is also documented. The announcement says that when OpenCode does not need the full JSON payload, it can set the engine's output parameter to Markdown, which it claims uses roughly half the tokens for the same task. The repository describes structured results with JSON, compact responses, Markdown output and engine-specific parameter validation. These are vendor claims about token efficiency rather than independently measured figures in the supplied material.
For freelancers and developers who run local models, the practical appeal is architectural. The announcement notes that because OpenCode is model-agnostic, many developers pair it with local LLMs such as Ollama or LM Studio so that code and data stay on their machine, and that web search is the capability such a setup lacks without an added integration. The plugin's value proposition is therefore not a new model but a way to keep a local-first workflow while still reaching live data.
The alternative the announcement describes is building a separate API integration: handling authentication, setting parameters and parsing responses yourself. The plugin replaces that with one integration and, per the announcement, removes the need to remember engine names or query formats because OpenCode selects the engine and parameters from the query. The repository frames the same benefit as engine-aware queries handled by the native tool's field mapping.
Cost and access terms appear in the repository but not in the announcement. The repository states that signing up at serpapi.com provides a free tier of 250 searches per month with no credit card required. It does not state pricing for paid tiers, and the supplied evidence contains no rate limits, latency figures or service-level commitments beyond that free allowance.
Troubleshooting guidance is included in the repository, which is useful for judging maturity. If the tool does not appear, the repository advises confirming the correct plugin key for the OpenCode version, confirming SERPAPI_API_KEY is available to the OpenCode process, and restarting. For an invalid key, it advises replacing the environment variable and restarting so the MCP header is rebuilt. For MCP connection problems it points to opencode mcp list, where the serpapi entry should report connected. Native request failures return an error message with the configured key redacted.
Coverage of the project's test suite is likewise provided by the repository: with fetch mocked, it spans mapping of request parameters, enforcement of trusted keys, HTTP failures, credentials that are missing, and resolved MCP header configuration. What that amounts to is a description of test coverage, not an independent audit; moreover, the supplied evidence contains no test results, no release version number, and no changelog.
Licensing is stated as MIT in the repository, and the announcement says the plugin is open source and points readers to the GitHub repo to inspect the implementation, report issues or request features. The announcement also says SerpApi is continuing to expand integrations across MCP, Claude Code and other AI tools, and invites contact at a published address if a user's tool lacks an integration.
Several things remain unverified in the supplied material. The announcement is a vendor post on a community platform and the repository is the vendor's own project page, so the performance and convenience claims are self-reported. There is no independent benchmark of search accuracy, no comparison against building a custom integration, and no stated support policy or versioning scheme. The announcement's token-saving figure for Markdown output is not accompanied by a described method or sample.
The event date is also unclear. The candidate record carries a source timestamp, but the supplied evidence does not state a release date, version number or publication date for the plugin itself, and the repository page carries no publication date. Readers should treat the plugin as available now based on the install instructions, without assuming a specific launch date from this material.
For this audience, the concrete implication is narrow but real: developers already running OpenCode, particularly with local models, can add live search by editing one config file and exporting one environment variable, and can fall back to a direct HTTPS tool if the MCP route is unavailable. The tradeoff is a dependency on a third-party search API and its key, plus a free tier of 250 searches per month that will not cover heavy use. Whether the engine-routing skill actually produces better results than a generic search is asserted by the vendor and not demonstrated in the evidence supplied here.