---
title: "Búsqueda Web Gratuita para Agentes de Codificación IA: Guía de Configuración de TinyFish Search + Fetch"
description: "Dale a tu agente de codificación IA búsqueda web y fetch de páginas gratis. TinyFish ofrece 30 búsquedas/min y 150 fetchs/min sin coste."
date: 2026-10-16
categories: ["ai"]
tags: ["ai-tools","tinyfish","coding-agents"]
---

import Button from "@components/widgets/Button.astro";
import Notice from "@components/widgets/Notice.astro";
import ListCheck from "@components/widgets/ListCheck.astro";
import Accordion from "@components/widgets/Accordion.astro";
import Tabs from "@components/widgets/Tabs.astro";
import Tab from "@components/widgets/Tab.astro";

Tu agente de codificación IA conoce Python, JavaScript, Docker, Kubernetes y mucho más. Pero pregúntale por una actualización de librería que salió la semana pasada, o por un breaking change en una versión nueva, y o alucina o te dice que mires los docs tú mismo.

La solución es darle a tu agente acceso a la web en vivo. Búsqueda web y fetch de páginas reales que funcionan en tiempo real.

[TinyFish](https://go.bitdoze.com/tinyfish) lo hizo gratis. Sin tarjeta, sin periodo de prueba. Búsqueda y fetch gratis para cada desarrollador y cada agente.

<Button text="Consigue tu Clave API Gratuita de TinyFish" link="https://go.bitdoze.com/tinyfish" variant="solid" color="blue" size="md" icon="arrow-right" />

## Lo que TinyFish te da gratis

Dos endpoints, ambos gratis:

**Search** toma una consulta y devuelve resultados JSON estructurados. No enlaces azules diseñados para ojos humanos, sino datos limpios y estables en ranking que tu agente puede parsear directamente. Tiempos de respuesta por debajo de 500ms. Puedes pasar pistas de ubicación e idioma para resultados geolocalizados.

**Fetch** toma una o más URLs y devuelve contenido limpio. La página se renderiza en un navegador Chromium real (JavaScript, SPAs, todo), y luego se eliminan barras de navegación, banners de cookies, anuncios y scripts. Recibes markdown, HTML o JSON. Tu modelo deja de pagar tokens por HTML basura.

<YouTubeEmbed
  url="https://www.youtube.com/embed/Hu_OGbBEW3M"
  label="TinyFish GRATIS Hace que los Agentes IA Sean Realmente Útiles"
/>

### Límites del nivel gratuito

| Endpoint | Límite de tasa | Coste |
|----------|----------------|-------|
| **Search** | 30 peticiones/min | Gratis |
| **Fetch** | 150 URLs/min | Gratis |
| **Agent** | 2 ejecuciones concurrentes | 1 crédito/paso |
| **Browser** | 5 sesiones concurrentes | 1 crédito/4 min |
| **Monitor** | 50 monitores/cuenta | $0.005/ejecución + la llamada Search o Fetch subyacente |
| **Research** | Beta | Abierto a todas las cuentas mientras esté en beta |

Para uso con agentes de codificación, Search y Fetch cubren la mayor parte de lo que necesitas. Los endpoints Agent y Browser cuestan créditos (recibes 500 gratis al registrarte), pero la mayoría de flujos de codificación ni los tocan. Las llamadas Search/Fetch subyacentes de Monitor cuentan para tu cupo diario gratuito, así que un puñado de comprobaciones programadas te cuesta la tarifa de $0.005 por ejecución y nada más.

### Estadísticas de uso real

Estas son estadísticas reales del dashboard de TinyFish que muestran cómo los agentes de codificación usan el nivel gratuito:

**Search API** — 40.6K peticiones totales con tiempo medio de respuesta de 360ms:

![Estadísticas de TinyFish Search API mostrando 40.6K peticiones](@assets/images/26/07/tinyfish-search.webp)

**Fetch API** — 65.6K peticiones totales. Fíjate cómo Codex CLI, OpenCode, Claude Code y otros agentes lo están usando:

![Estadísticas de TinyFish Fetch API mostrando 65.6K peticiones](@assets/images/26/07/tiny-fishfetch.webp)

<Notice type="success" title="Los fetchs fallidos son gratis">
Si una URL devuelve un error o hace timeout, no cuenta contra tu cuota. Solo pagas por los fetchs que tienen éxito.
</Notice>

## Por qué tu agente de codificación necesita acceso web

La mayoría de agentes de codificación dependen de los datos de entrenamiento del modelo para cualquier cosa fuera de tu codebase. Eso funciona para patrones estables y APIs bien documentadas. Se rompe con versiones recientes, peculiaridades específicas de versiones, soluciones de la comunidad en GitHub y documentación actual.

Darle a tu agente un pipeline de búsqueda+fetch cambia la respuesta de "creo que funciona así" a "aquí está la documentación actual".

### Ahorro de tokens

TinyFish Fetch elimina navegación, scripts y boilerplate de las páginas antes de devolver el contenido. Tu modelo procesa el contenido real del artículo, no tres kilobytes de banners de consentimiento de cookies y enlaces de pie de página. Esto recorta el uso de tokens por fetch comparado con fetch de HTML crudo.

## Configurando TinyFish con tu agente de codificación

Hay cuatro formas de cablear TinyFish en tu agente. Elige la que encaje con tu montaje.

<Button text="Consigue una Clave API Gratuita de TinyFish" link="https://go.bitdoze.com/tinyfish" variant="solid" color="blue" size="md" icon="arrow-right" />

### Opción 1: CLI + Skill (Recomendada)

La CLI es la opción más portable. Funciona con cualquier agente que pueda ejecutar comandos de shell, y el skill le enseña a tu agente cuándo usar búsqueda vs fetch.

**Instala la CLI:**

```bash
npm install -g @tiny-fish/cli@latest
```

**Autentícate:**

```bash
tinyfish auth login
```

Esto abre la página de claves API en tu navegador. Pega tu clave cuando te la pida. La clave se guarda en `~/.tinyfish/config.json`.

Para CI/CD o montajes no interactivos:

```bash
echo $TINYFISH_API_KEY | tinyfish auth set
```

**Verifica que funciona:**

```bash
tinyfish --version
tinyfish auth status --pretty
```

**Instala el skill** (enseña a tu agente la jerarquía de herramientas):

```bash
npx skills add github.com/tinyfish-io/tinyfish-cookbook --skill use-tinyfish
```

El skill cubre la escalera de escalada: search para encontrar URLs, fetch para leer páginas, agent para tareas interactivas de navegador, y browser para control CDP en bruto. El mismo formato `SKILL.md` alimenta skills de calidad de diseño — mira mi comparativa de [mejores skills de IA para diseño web](/es/mejores-skills-ia-diseno-web/).

**Pruébalo:**

```bash
# Search
tinyfish search query "best Docker monitoring tools 2026" --pretty

# Fetch
tinyfish fetch content get --format markdown "https://docs.docker.com"
```

### Opción 2: Servidor MCP

Si tu agente soporta MCP (Model Context Protocol), esta es la integración más limpia:

```json
{
  "mcpServers": {
    "tinyfish": {
      "url": "https://mcp.tinyfish.ai"
    }
  }
}
```

Mete esto en la config MCP de tu agente y reinicia. El agente ve Search y Fetch como herramientas nativas.

Funciona con: Claude Code, Cursor, Codex, ChatGPT desktop y cualquier cliente compatible con MCP.

### Opción 3: API REST

Para integraciones personalizadas o agentes que no soportan MCP:

```bash
# Search
curl "https://api.search.tinyfish.ai?query=docker+compose+healthcheck" \
  -H "X-API-Key: $TINYFISH_API_KEY"

# Fetch
curl -X POST https://api.fetch.tinyfish.ai \
  -H "X-API-Key: $TINYFISH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://docs.docker.com/compose/how-tos/startup-order/"]}'
```

Ambos endpoints devuelven JSON. Search te da resultados rankeados con títulos, snippets y URLs. Fetch te da el contenido limpio de la página más metadatos (título, idioma, autor, fecha de publicación).

### Opción 4: SDKs

Para uso programático en tus propias herramientas:

<Tabs>
<Tab name="TypeScript">
```bash
npm install @tiny-fish/sdk
```
```typescript
import { TinyFish } from "@tiny-fish/sdk";

const client = new TinyFish(); // reads TINYFISH_API_KEY from env

// Search
const results = await client.search.query("best React state management 2026");

// Fetch
const content = await client.fetch.content.get({
  urls: ["https://tanstack.com/query/latest"],
  format: "markdown",
});
```
</Tab>
<Tab name="Python">
```bash
pip install tinyfish
```
```python
from tinyfish import TinyFish

client = TinyFish()  # reads TINYFISH_API_KEY from env

# Search
results = client.search.query("best React state management 2026")

# Fetch
content = client.fetch.content.get(
    urls=["https://tanstack.com/query/latest"],
    format="markdown"
)
```
</Tab>
</Tabs>

## Guías de configuración por agente

### Agente de codificación Pi

Pi tiene soporte nativo de TinyFish a través del paquete [pi-tinyfish](https://github.com/x1any/pi-tinyfish):

<Tabs>
<Tab name="npm">
```bash
pi install npm:pi-tinyfish
```
</Tab>
<Tab name="git">
```bash
pi install git:github.com/x1any/pi-tinyfish
```
</Tab>
</Tabs>

Pon tu clave API:

```bash
export TINYFISH_API_KEY="your_api_key_here"
```

Añade eso a tu perfil de shell (`~/.bashrc`, `~/.zshrc`, o `~/.config/fish/config.fish`) para que persista entre sesiones.

Eso es todo. La próxima vez que arranques Pi, el agente puede llamar a `tinyfish_search` y `tinyfish_fetch` como herramientas. Cuando necesite buscar algo de una librería, consultar docs o verificar un formato de config, buscará en la web y hará fetch de las páginas relevantes automáticamente.

Mira la [guía de configuración de Pi](/es/guia-configuracion-pi-agent/) para las instrucciones completas de instalación de Pi.

### Hermes Agent

[Hermes Agent](/es/guia-configuracion-hermes-agent/) de Nous Research tiene una herramienta de búsqueda web integrada, pero TinyFish te da más control y añade fetch de páginas limpio.

**Enfoque MCP** (el más limpio si tu versión de Hermes lo soporta):

```json
{
  "mcpServers": {
    "tinyfish": {
      "url": "https://mcp.tinyfish.ai"
    }
  }
}
```

**Enfoque CLI** (funciona en todas partes):

```bash
npm install -g @tiny-fish/cli@latest
tinyfish auth login
```

Hermes puede entonces llamar a `tinyfish search query "..."` y `tinyfish fetch content get <urls>` a través de su acceso a la terminal.

### OpenClaw

[OpenClaw](/es/guia-configuracion-openclaw/) soporta servidores MCP. Añade el servidor MCP de TinyFish a tu config de OpenClaw:

```json
{
  "mcpServers": {
    "tinyfish": {
      "url": "https://mcp.tinyfish.ai"
    }
  }
}
```

O instala el skill:

```bash
npx skills add github.com/tinyfish-io/tinyfish-cookbook --skill use-tinyfish
```

### Claude Code

Claude Code tiene un helper de un solo paso para cablear TinyFish como backend de búsqueda web/fetch:

```bash
tinyfish config-claude
```

Esto instala la configuración del servidor MCP automáticamente. Para quitarla:

```bash
tinyfish config-claude --remove
```

### OpenCode

[OpenCode](/es/guia-configuracion-opencode/) soporta servidores MCP. Añade a tu config de OpenCode:

```json
{
  "mcpServers": {
    "tinyfish": {
      "url": "https://mcp.tinyfish.ai"
    }
  }
}
```

### Cursor, Codex y otros

Cualquier agente que soporte MCP puede usar la misma configuración:

```json
{
  "mcpServers": {
    "tinyfish": {
      "url": "https://mcp.tinyfish.ai"
    }
  }
}
```

Para agentes sin soporte MCP, usa las opciones de CLI o API REST.

## Ejemplos prácticos

Esto es lo que tu agente puede hacer con acceso web gratuito:

### Consultar documentación actual

```bash
tinyfish fetch content get --format markdown "https://docs.docker.com/compose/how-tos/startup-order/"
```

Tu agente lee los docs reales en vez de adivinar desde los datos de entrenamiento.

### Buscar soluciones a errores

```bash
tinyfish search query "TypeError: Cannot read property of undefined React 19" --pretty
```

Encuentra issues de GitHub, respuestas de Stack Overflow y posts de blog sobre el error exacto.

### Comprobar versiones de librerías y changelogs

```bash
tinyfish search query "Next.js 15 breaking changes" --pretty
tinyfish fetch content get --format markdown "https://nextjs.org/blog/next-15"
```

Verifica qué cambió antes de que tu agente sugiera código que funciona con la API vieja.

### Investigar buenas prácticas

```bash
tinyfish search query "Docker healthcheck best practices 2026" --pretty
```

Obtén recomendaciones actuales en vez de patrones desactualizados de 2023.

## La escalera de escalada de herramientas

El skill de TinyFish le enseña a tu agente a elegir la herramienta adecuada para el trabajo:

| Herramienta | Cuándo usarla | Velocidad | Coste |
|-------------|---------------|-----------|-------|
| **search** | Encontrar URLs, hechos actuales, docs, precios | La más rápida | Gratis |
| **fetch** | Leer URLs conocidas, obtener contenido limpio | Rápida | Gratis |
| **research** | Informes con citas sintetizados de múltiples fuentes | Minutos | Beta |
| **monitor** | Recomprobar una página o tema en un calendario | Programada | $0.005/ejecución |
| **agent** | Interactuar con páginas, clicar, rellenar formularios | Más lenta | Créditos |
| **browser** | Control CDP en bruto para automatización compleja | La más lenta | Créditos |

Empieza con la herramienta más ligera que pueda responder la pregunta. Escala solo cuando haga falta.

### Monitor: comprobaciones programadas de páginas y temas

Monitor es una pieza más nueva de la plataforma que se asienta sobre Search y Fetch. Apúntalo a una URL y vuelve a hacer fetch en tu calendario, compara el contenido extraído y marca lo que cambió. Apúntalo a una consulta de búsqueda en su lugar y vigila nuevos resultados. Las alertas van al dashboard, a un webhook o a email — útil para seguir el changelog de una dependencia o la página de precios de un competidor. Las ejecuciones cuestan $0.005 cada una (un monitor diario cuesta unos $0.15/mes), y el fetch subyacente sigue contando contra tu cupo gratuito en vez de contra créditos.

### Research API: informes con citas bajo demanda

La Research API está en beta y abierta a todas las cuentas. Haces `POST` de una pregunta a `https://agent.tinyfish.ai/v1/automation/run-research` y devuelve en streaming un informe respaldado por fuentes con citas — no una lista de enlaces, una síntesis real. Es más lenta que Search (las ejecuciones tardan minutos, en streaming por SSE), pero responde el tipo de pregunta que de otro modo le costaría a tu agente una docena de idas y vueltas de search+fetch. Tengo más detalles en mi [review de TinyFish](/es/tinyfish-busqueda-web-agentes-ia/).

## Comparación con alternativas

| Característica | TinyFish Fetch | Firecrawl | Fetch nativo del LLM | Playwright artesanal |
|----------------|----------------|-----------|----------------------|----------------------|
| **Renderizado JavaScript** | Sí (Chromium real) | Sí | No (solo HTML estático) | Sí |
| **Extracción de contenido limpio** | Sí | Sí | HTML crudo | Manual |
| **Stealth/anti-bot** | Integrado | Varía | No | Configuración manual |
| **Nivel gratuito** | Sí (Search + Fetch) | Gratis limitado | Depende del proveedor | Pagas el cómputo |
| **Optimización de tokens** | Elimina boilerplate | Elimina boilerplate | HTML completo | Manual |
| **Agrupación multi-URL** | Hasta 10 URLs/llamada | Varía | No | Manual |

La principal ventaja de TinyFish sobre hacer Playwright a mano es que no gestionas instancias de navegador, rotación de proxies ni detección anti-bot. La principal ventaja sobre el fetch nativo del LLM es el renderizado JavaScript — la mayoría de sitios de docs modernos son SPAs que devuelven cascarones vacíos sin él.

<Accordion label="¿Cómo se compara TinyFish con Brave Search API?" group="alternatives">
Brave Search API ofrece un nivel gratuito (2.000 consultas/mes) pero devuelve resultados de búsqueda tradicionales sin fetch de páginas. Obtienes títulos, URLs y snippets, pero no el contenido completo de la página. TinyFish te da tanto búsqueda como fetch limpio de páginas gratis, con límites de tasa más altos (30 búsquedas/min = ~43.200/mes).
</Accordion>

<Accordion label="¿Puedo usar TinyFish con mi propia clave API de OpenCode Go?" group="alternatives">
TinyFish es un servicio independiente de OpenCode Go. Necesitas una clave API de TinyFish desde [agent.tinyfish.ai](https://go.bitdoze.com/tinyfish). La buena noticia es que es gratis, así que puedes usar tanto OpenCode Go para tus modelos LLM como TinyFish para acceso web sin ningún conflicto.
</Accordion>

<Accordion label="¿Qué pasa si alcanzo los límites de tasa?" group="alternatives">
Las peticiones se estrangulan o rechazan hasta que se reinicia la ventana del límite. Para Search, el límite es de 30 peticiones por minuto. Para Fetch, son 150 URLs por minuto. Si necesitas límites más altos, hay planes de pago en [tinyfish.ai/pricing](https://tinyfish.ai/pricing).
</Accordion>

## Qué me gusta y qué no

Llevo semanas usando TinyFish a través de Pi y Mastra. Esta es la opinión honesta.

**Lo que funciona bien:** Los resultados de búsqueda son limpios y rápidos. Fetch renderiza las SPAs correctamente, lo que importa para sitios de docs basados en React. El nivel gratuito cubre el uso diario con agentes de codificación sin problemas. El ahorro de tokens por el contenido limpio se nota.

**Lo que podría mejorar:** Fetch puede ser lento en páginas pesadas (5-10 segundos en sitios con mucho JavaScript). Search devuelve ocasionalmente resultados desactualizados para eventos muy recientes. Y los endpoints Agent/Browser se ponen caros rápido si necesitas automatización interactiva.

**En resumen:** Para darle a tu agente de codificación acceso web, el nivel gratuito Search + Fetch funciona bien. Lo tengo cableado en Pi a través de pi-tinyfish y en Mastra a través del SDK. Se ha convertido en una parte estándar de mi configuración de agentes.

<Button text="Empieza con TinyFish (Gratis)" link="https://go.bitdoze.com/tinyfish" variant="solid" color="blue" size="md" icon="arrow-right" />

## Artículos relacionados

- [TinyFish: API Gratuita de Búsqueda Web y Fetch para tus Agentes de Codificación IA](/es/tinyfish-busqueda-web-agentes-ia/) — visión detallada de TinyFish
- [Extiende Muse AI con MCPs Personalizados](/es/muse-tinyfish-busqueda-fetch/) — TinyFish, Composio y skills dentro del agente de Meta
- [Construye tu Propio Agente IA con Mastra](/build-ai-agent-mastra/) — guía completa usando TinyFish con Mastra
- [Guía de configuración del agente de codificación Pi](/es/guia-configuracion-pi-agent/) — instala y configura Pi
- [Guía de configuración de Hermes Agent](/es/guia-configuracion-hermes-agent/) — instala y configura Hermes
- [OpenCode Go: 31 Modelos de Codificación IA por $10/Mes](/es/opencode-go-plan/) — modelos baratos para tu agente