Uma plataforma para construir, pesquisar, extrair, enriquecer, mapear e monitorar dados em toda a web.

Peça qualquer conjunto de dados em palavras simples, e o SpecStream o constrói a partir de toda a web ao vivo: cada correspondência encontrada, extraída e enriquecida em registros estruturados, e então monitorada para alterações. Ele funciona através da API e MCP, e dentro de Planilhas, CRMs, Slack, n8n, Zapier e outras ferramentas que as equipes já usam.

Produto	O que faz	Preço
Search API	`GET /v1/web-search`. A API de pesquisa web mais precisa do mundo: 97,9 F-score em todas as 1.000 perguntas SimpleQA Verified e 64,0 item F1 em todas as 200 tarefas WideSearch (pontuações e método). Responde a uma pergunta da web ao vivo em segundos.	$5 por 1.000 pesquisas, $1 por 1.000 com `speed=fast`
Extract API	`POST /v1/extract`. O texto principal de até 20 páginas web, PDF, Word ou arquivos Excel por chamada. A ferramenta MCP é `read_pages`.	$0,80 por 1.000 páginas. Uma página sem texto não é cobrada.
Deep Search	Pergunte em palavras simples. Obtenha todas as correspondências na web ao vivo, em linhas estruturadas. Também enriquece uma lista que você tem e monitora alterações.	$0,05, $0,15 ou $1 por linha

Pesquisa:

curl -G https://api.specstream.ai/v1/web-search \
  -H "Authorization: Bearer $SPECSTREAM_API_KEY" \
  --data-urlencode "q=Qual é a população do Japão?"

Extração:

curl https://api.specstream.ai/v1/extract \
  -H "Authorization: Bearer $SPECSTREAM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://example.com"]}'

Search API em Python: responda a uma pergunta da web ao vivo em segundos.

# pip install specstream-client
import os
from specstream_client import Client

client = Client(os.environ["SPECSTREAM_API_KEY"])

search = client.web_search(q="Qual é a população do Japão?")
for source in search["sources"][:1]:
    print(source["title"], source["url"], source["snippet"])

Extract API em Python: o texto principal de até 20 páginas web, PDF, Word ou arquivos Excel por chamada.

# pip install specstream-client
import os
from specstream_client import Client

client = Client(os.environ["SPECSTREAM_API_KEY"])

extract = client.extract_pages({"urls": ["https://example.com"]})
for page in extract["results"][:1]:
    print(page["title"], page["url"], page["text"])

Search API em TypeScript:

// npm install @specstream/sdk
import { Client } from "@specstream/sdk";

const client = new Client({ apiKey: process.env.SPECSTREAM_API_KEY! });

const search = await client.webSearch({ q: "Qual é a população do Japão?" });
for (const source of search.sources.slice(0, 1)) {
  console.log(source.title, source.url, source.snippet);
}

Extract API em TypeScript:

// npm install @specstream/sdk
import { Client } from "@specstream/sdk";

const client = new Client({ apiKey: process.env.SPECSTREAM_API_KEY! });

const extract = await client.extractPages({ urls: ["https://example.com"] });
for (const page of extract.results.slice(0, 1)) {
  console.log(page.title, page.url, page.text);
}

URL de origem e tempo de leitura em cada valor.
A Search API e a Extract API não precisam de cotação ou aprovação. Cada pesquisa ou página tem seu preço fixo debitado do seu saldo.
No Deep Search, o custo máximo de uma execução é mostrado e aprovado antes de ser executado. Apenas linhas entregues são cobradas, e uma execução que não encontra nada não custa nada.
Uma solicitação salva é reexecutada a cada hora até anualmente, e cada linha é marcada como alterada, inalterada ou não correspondente.
Seu agente trabalha na sua conta, dentro dos limites de gastos que você definir.

Substituição para a API que você já chama

O SpecStream atende chamadas escritas para estas APIs de pesquisa em seu próprio endereço, no formato de resposta de cada API. Para trocar, mude o endereço base e a chave. Cada chamada de pesquisa é uma pesquisa web Search API na sua chave SpecStream. Uma chamada de substituição executa a pesquisa rápida: $0,001 para até 10 resultados ($1 por 1.000 pesquisas), e cada 10 resultados adicionais na mesma chamada adicionam $0,0012. Uma chamada que solicita uma resposta ou o modo completo da API executa a pesquisa padrão: $0,005 para até 10 resultados, e $0,006 para cada 10 adicionais.

API que você chama	Endereço base que você tem	Endereço SpecStream	Onde vai a chave SpecStream
Tavily	`https://api.tavily.com`	`https://api.specstream.ai/tavily`	Token Bearer ou `api_key`
Exa	`https://api.exa.ai`	`https://api.specstream.ai/exa`	`x-api-key` ou Token Bearer
Brave Search API	`https://api.search.brave.com`	`https://api.specstream.ai`	`X-Subscription-Token`
Serper	`https://google.serper.dev`	`https://api.specstream.ai/serper`	`X-API-KEY`
Bing Web Search API v7	`https://api.bing.microsoft.com/v7.0/search`	`https://api.specstream.ai/v7.0/search`	`Ocp-Apim-Subscription-Key`
Google Custom Search JSON API	`https://www.googleapis.com` ou `https://customsearch.googleapis.com`	`https://api.specstream.ai`	`key=` (`cx` é aceito e não usado)
SearXNG (JSON)	endereço da sua instância	`https://api.specstream.ai/searxng/<key>`	no endereço, `key=`, `X-API-Key` ou Token Bearer
Firecrawl v2	`https://api.firecrawl.dev`	`https://api.specstream.ai/firecrawl` (JavaScript SDK e aplicativos) ou `https://api.specstream.ai` (Python SDK)	Token Bearer

Os SDKs Python oficiais do Tavily e Exa aceitam o endereço como argumento:

import os
from tavily import TavilyClient
from exa_py import Exa

tavily = TavilyClient(api_key=os.environ["SPECSTREAM_API_KEY"], api_base_url="https://api.specstream.ai/tavily")
exa = Exa(api_key=os.environ["SPECSTREAM_API_KEY"], base_url="https://api.specstream.ai/exa")

Uma chamada que não especifica o número de resultados retorna 10 resultados, a $0,001 na pesquisa rápida. O padrão do Brave é 20: envie count=20 para 20 resultados a $0,0022.
Uma chamada Firecrawl /v2/scrape é uma página da Extract API a $0,0008. O Firecrawl JavaScript SDK funciona com este endereço. O Firecrawl Python SDK aceita a raiz do host: Firecrawl(api_key=..., api_url="https://api.specstream.ai").
Campos de requisição e resposta de cada rota: specstream.ai/agents.md. Crie uma chave em Agents & API em specstream.ai/workspace. Novas contas começam com $10 de crédito, sem cartão.

Uma requisição, seu preço e as linhas com suas fontes

Este repositório contém o que você instala ao redor do SpecStream: configuração do cliente MCP, plugins e habilidades de agente, SDKs, o nó n8n, uma GitHub Action e exemplos. O produto em si roda em specstream.ai. Licenciado sob MIT.

Caminho	O que é
`server.json`	Entrada para o Registro MCP oficial, `ai.specstream/specstream`
`skills/`	Habilidades do agente: `search-web`, `extract-pages`, `compile`, `review-work`, `approve-work`, `continue-work`
`plugins/claude-code/`	Plugin Claude Code (servidor MCP e as seis habilidades)
`plugins/github-agent/`	Plugin para agentes que leem o formato agent-plugins
`.cursor-plugin/`	Plugin Cursor
`packages/sdk-py/`	`specstream-client`: Cliente Python e o comando `specstream`
`packages/sdk-ts/`	`@specstream/sdk`: Cliente TypeScript
`packages/langchain-specstream/`	`langchain-specstream`: Ferramentas LangChain e um recuperador
`packages/llama-index-tools-specstream/`	`llama-index-tools-specstream`: Especificação de ferramenta LlamaIndex e um recuperador
`packages/crewai-specstream/`	`crewai-specstream`: Ferramentas CrewAI
`packages/specstream-haystack/`	`specstream-haystack`: Componente de busca de lista Haystack e ferramenta de agente
`packages/ai-sdk/`	`@specstream/ai-sdk`: Ferramentas Vercel AI SDK
`packages/mcp-stdio/`	`specstream-mcp-stdio`: Proxy stdio para clientes que só iniciam servidores locais
`integrations/n8n/`	`n8n-nodes-specstream`: Nó comunitário n8n
`integrations/opencode/`	`opencode-specstream`: Plugin OpenCode (servidor MCP e as quatro habilidades)
`integrations/openclaw/`	`@specstream/openclaw-plugin`: Plugin OpenClaw (encontre uma lista, leia suas linhas, quatro habilidades)
`integrations/pi/`	`@specstream/pi-package`: Pacote Pi (o servidor MCP hospedado e quatro habilidades)
`integrations/obsidian/`	Plugin Obsidian: peça dados em uma nota, aprove o preço, obtenha uma tabela Markdown com uma fonte para cada valor
`integrations/open-webui/`	Ferramenta Open WebUI: cotar, aprovar e ler resultados de um chat, além da rota MCP nativa
`integrations/anythingllm/`	Habilidade de agente AnythingLLM, além da rota MCP
`integrations/convex/`	Componente Convex (`@specstream/convex`): dados da web ao vivo como registros em suas tabelas Convex, uma fonte para cada valor
`integrations/fivetran/`	Conector Fivetran Connector SDK: suas listas, registros e cada valor com sua página de origem em seu warehouse
`integrations/airbyte/`	Fonte Airbyte (somente manifesto): suas listas e registros, cada valor com sua página de origem
`integrations/meltano/`	`tap-specstream` no PyPI: Singer tap para Meltano e qualquer destino Singer, listas e registros com a página de origem de cada valor
`integrations/coda/`	Pacote Coda: sincronize uma lista em uma tabela com uma coluna de origem para cada valor, precifique uma requisição, encontre uma lista a partir de um botão
`plugins/grok/`	Plugin Grok Build (o servidor MCP hospedado e quatro habilidades)
`plugins/kiro/`	Poder Kiro (o servidor MCP hospedado e quatro habilidades)
`integrations/vscode/`	Extensão VS Code: login MCP e chat `@specstream`
`actions/find-action/`	GitHub Action que executa uma requisição e envia um CSV
`Formula/`	Fórmula Homebrew para a linha de comando
`examples/`	Python SDK, TypeScript SDK, OpenAI Agents SDK e LangChain

Conecte um agente

O servidor MCP é https://api.specstream.ai/mcp (Streamable HTTP). Seu agente trabalha na sua conta: o mesmo saldo, permissões e limites de gastos que você tem.

Abra Agents & API no workspace e crie uma chave de API. Dê a ela apenas o que a tarefa precisa: ler, preparar ou executar, os projetos que pode usar, uma expiração e um limite de gastos.
Coloque-a em uma variável de ambiente, para que nenhum arquivo a armazene:
```
export SPECSTREAM_API_KEY="ss_live_..."
```
Adicione o servidor ao seu cliente, abaixo.

Clientes que suportam login MCP podem se conectar sem uma chave. Cada guia em specstream.ai/docs/mcp mostra as etapas atuais.

Novas contas começam com $10 de crédito, sem cartão.

Claude

No Claude, vá para Customize > Connectors, escolha Add custom connector, nomeie-o SpecStream e cole https://api.specstream.ai/mcp. Etapas para login e chave: docs/mcp/claude.

Claude Code

claude mcp add --transport http specstream https://api.specstream.ai/mcp \
  --header "Authorization: Bearer $SPECSTREAM_API_KEY"

Ou instale o plugin, que adiciona o servidor e as seis habilidades. Ele faz o login pelo seu navegador na primeira vez, então nenhuma chave é necessária:

/plugin marketplace add specstream/specstream-tools
/plugin install specstream@specstream

ChatGPT

Vá para ChatGPT Plugins, escolha o botão de mais, depois Add custom MCP server. Cole https://api.specstream.ai/mcp em Connection e defina Authentication como OAuth. Etapas: docs/mcp/chatgpt.

Codex

Adicione a ~/.codex/config.toml:

[mcp_servers.specstream]
url = "https://api.specstream.ai/mcp"
bearer_token_env_var = "SPECSTREAM_API_KEY"

Cursor

Adicione a ~/.cursor/mcp.json, ou .cursor/mcp.json em um projeto:

{
  "mcpServers": {
    "specstream": {
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  }
}

VS Code

A extensão VS Code suporta login MCP: instale a extensão SpecStream VS Code. Depois de instalada, abra a paleta de comandos (Ctrl+Shift+P ou Cmd+Shift+P), execute SpecStream: Sign in e faça login no seu navegador. O servidor MCP é configurado automaticamente.

Ou configure manualmente em .vscode/mcp.json:

{
  "servers": {
    "specstream": {
      "type": "http",
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  }
}

Cline (VS Code extension)

Adicione a ~/.codex/mcp.json ou ao arquivo de configuração MCP do Cline:

{
  "mcpServers": {
    "specstream": {
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  }
}

Goose

goose mcp add --name specstream --url https://api.specstream.ai/mcp --header "Authorization: Bearer $SPECSTREAM_API_KEY"

OpenCode

Adicione a ~/.opencode/mcp.json:

{
  "mcpServers": {
    "specstream": {
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  }
}

OpenClaw

Adicione a ~/.openclaw/mcp.json:

{
  "mcpServers": {
    "specstream": {
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  }
}

Continue (VS Code extension & JetBrains)

Adicione a ~/.continue/config.json:

{
  "mcpServers": [
    {
      "name": "specstream",
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  ]
}

Windsurf

Adicione a ~/.windsurf/mcp.json:

{
  "mcpServers": {
    "specstream": {
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  }
}

Copilot (GitHub)

Adicione a ~/.github/copilot/mcp.json:

{
  "mcpServers": {
    "specstream": {
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  }
}

Replit

Vá para a página de integração MCP do Replit e autorize. Ou defina a variável de ambiente SPECSTREAM_API_KEY e adicione o MCP nas configurações do agente Replit.

PearAI

Use a configuração do Cursor: adicione a ~/.pearai/mcp.json:

{
  "mcpServers": {
    "specstream": {
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  }
}

Lovable

Adicione a ~/.lovable/mcp.json:

{
  "mcpServers": {
    "specstream": {
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  }
}

Codium (Windsurf)

O Codium usa a configuração do Windsurf. Adicione a ~/.windsurf/mcp.json conforme descrito acima.

Pi (Desktop)

O Pi suporta MCP. Adicione o servidor do SpecStream nas configurações do agente Pi. Consulte a documentação para etapas detalhadas.

AutoGPT

Adicione o servidor MCP ao arquivo mcp_settings.json do AutoGPT:

{
  "mcpServers": {
    "specstream": {
      "url": "https://api.specstream.ai/mcp",
      "headers": { "Authorization": "Bearer ${env:SPECSTREAM_API_KEY}" }
    }
  }
}

Agno (antes Phidata)

Adicione o servidor na configuração do Agno:

from agno.agent import Agent
from agno.tools.mcp import MCPTools

mcp_tools = MCPTools(endpoint="https://api.specstream.ai/mcp", api_key=os.environ["SPECSTREAM_API_KEY"])
agent = Agent(tools=[mcp_tools])

OpenAI Agents SDK

from agents import Agent, Runner
from agents.mcp import MCPServer

agent = Agent(
    name="SpecStream agent",
    instructions="Use as ferramentas SpecStream para pesquisar e extrair dados da web.",
    mcp_servers=[MCPServer(url="https://api.specstream.ai/mcp", headers={"Authorization": f"Bearer {os.environ['SPECSTREAM_API_KEY']}"})],
)

LangChain

from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain.tools.mcp import MCPTool
from langchain_community.chat_models import ChatOpenAI

mcp_tools = MCPTool.from_url(
    url="https://api.specstream.ai/mcp",
    headers={"Authorization": f"Bearer {os.environ['SPECSTREAM_API_KEY']}"},
)

LlamaIndex

from llama_index.core import Settings
from llama_index.tools.mcp import MCPToolSpec

mcp_spec = MCPToolSpec(url="https://api.specstream.ai/mcp", headers={"Authorization": f"Bearer {os.environ['SPECSTREAM_API_KEY']}"})
Settings.llm = OpenAI(model="gpt-4")

CrewAI

from crewai import Agent, Task
from crewai.tools import tool
from mcp import ClientSession

@tool("SpecStream")
async def specstream_tool(query: str):
    """Pesquise na web usando SpecStream."""
    async with ClientSession(url="https://api.specstream.ai/mcp", headers={"Authorization": f"Bearer {os.environ['SPECSTREAM_API_KEY']}"}) as session:
        return await session.call_tool("web_search", {"query": query})

Oh, você também pode usar o pacote crewai-specstream:

from crewai_specstream import SpecStreamTool

tool = SpecStreamTool(api_key=os.environ["SPECSTREAM_API_KEY"])

Haystack

from specstream_haystack import SpecStreamWebSearch

searcher = SpecStreamWebSearch(api_key=os.environ["SPECSTREAM_API_KEY"])
results = searcher.run(query="Qual é a população do Japão?")

Vercel AI SDK

import { experimental_createMCPClient } from "ai";

const mcpClient = await experimental_createMCPClient({
  transport: {
    type: "http",
    url: "https://api.specstream.ai/mcp",
    headers: { Authorization: `Bearer ${process.env.SPECSTREAM_API_KEY!}` }
  }
});

const tools = await mcpClient.tools();

Ou use o pacote @specstream/ai-sdk:

import { specstreamTools } from "@specstream/ai-sdk";

const tools = specstreamTools({ apiKey: process.env.SPECSTREAM_API_KEY! });

Habilidades do agente

As habilidades do agente definem ações específicas que o SpecStream pode executar. Elas estão em skills/ e são carregadas automaticamente quando o servidor MCP é adicionado. Para Claude Code, as seis habilidades são instaladas como parte do plugin.

Habilidade	Arquivo	Descrição
`search-web`	`skills/search-web.md`	Pesquise na web ao vivo e obtenha resultados com fontes e trechos
`extract-pages`	`skills/extract-pages.md`	Extraia o texto principal de páginas web, PDFs, documentos Word ou arquivos Excel
`compile`	`skills/compile.md`	Compile um conjunto de dados a partir de uma descrição em linguagem natural em Deep Search
`review-work`	`skills/review-work.md`	Revise o trabalho pendente do Deep Search antes de ser executado
`approve-work`	`skills/approve-work.md`	Aprove o Deep Search que requer aprovação
`continue-work`	`skills/continue-work.md`	Continue uma execução existente do Deep Search por mais dados

Preços e faturamento

Search API: $5 por 1.000 pesquisas (padrão) ou $1 por 1.000 (rápido). Sem assinatura, sem taxas mensais.
Extract API: $0,80 por 1.000 páginas. Apenas páginas com texto são cobradas.
Deep Search: $0,05, $0,15 ou $1 por linha, dependendo da complexidade. Apenas linhas entregues são cobradas. Nenhuma cobrança se nenhum resultado for encontrado.
Drop-in: Preços diferentes por chamada, consulte a documentação acima.
Crédito inicial: Novas contas recebem $10 de crédito, sem necessidade de cartão de crédito.

Licença

MIT. Veja o arquivo LICENSE para detalhes completos.

Perguntar na sua IA favorita

Prévia

Documentação