CrawlForge
Guía para principiantes

Guía de Optimización de Credits

Minimice los costos de scraping eligiendo las herramientas adecuadas, implementando estrategias de caché inteligentes y optimizando sus flujos de trabajo para obtener el máximo valor.

Estrategia de selección de herramientas
Estrategias de caché
Lotes vs. individual
Análisis de costo/beneficio

Logros rápidos (ahorre 50-80%)

Use fetch_url en lugar de search_web cuando conozca la URL
Ahorra 4 credits por solicitud (1 credit frente a 5 credits)

💰 80% de reducción de costo

Pruebe el scraping estático antes de la automatización del navegador
Use fetch_url (1 credit) antes que scrape_with_actions (5 credits)

💰 80% de reducción de costo para contenido estático

Almacene los resultados en caché localmente
Guarde los datos extraídos en Redis o en una base de datos para evitar volver a hacer scraping de las mismas URL

💰 Más del 90% de reducción en solicitudes repetidas

Use batch_scrape para múltiples URL
Mismo costo (1 credit/URL) pero más rápido y eficiente que las solicitudes individuales

⚡ Rendimiento 5 veces más rápido

1. Estrategia de selección de herramientas

Comience siempre con la herramienta más económica que satisfaga sus necesidades y solo actualice si es necesario.

  • 1. ¿Conoce la URL?
    • ✅ Sí → Use fetch_url (1 credit)
    • ❌ No → Use search_web (5 credits)
  • 2. ¿Está el contenido en el HTML inicial?
    • ✅ Sí → Use fetch_url (1 credit) + analice localmente (gratis)
    • ❌ No (renderizado con JavaScript) → Use scrape_with_actions (5 credits)
  • 3. ¿Necesita extracción estructurada?
    • ✅ Sí → Use scrape_structured (2 credits)
    • ❌ No (el HTML sin procesar es suficiente) → Use fetch_url (1 credit)
  • 4. ¿Necesita investigación impulsada por IA?
    • ✅ Sí → Use deep_research (10 credits)
    • ❌ No → Use alternativas más económicas

Comparación de costos por caso de uso

Caso de usoHerramienta incorrectaHerramienta correctaAhorro
Obtener HTMLsearch_web (5)fetch_url (1)80%
Extraer textoscrape_with_actions (5)extract_text (1)80%
Obtener metadatosscrape_structured (2)extract_metadata (1)50%
Investigar un temadeep_research (10)search_web (5) + fetch_url (1×3)20%

Ejemplo: extracción de datos de productos

Incorrecto (10 credits)

Typescript
// Using deep_research for simple task
const response = await fetch(
  'https://crawlforge.dev/api/v1/tools/deep_research',
  {
    method: 'POST',
    headers: {
      'X-API-Key': apiKey,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      topic: 'Product details',
      sources: ['https://shop.com/product/123']
    })
  }
);

// Cost: 10 credits 💸

Correcto (2 credits)

Typescript
// Using scrape_structured for known URL
const response = await fetch(
  'https://crawlforge.dev/api/v1/tools/scrape_structured',
  {
    method: 'POST',
    headers: {
      'X-API-Key': apiKey,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      url: 'https://shop.com/product/123',
      selectors: {
        title: 'h1.product-name',
        price: 'span.price'
      }
    })
  }
);

// Cost: 2 credits ✅ (80% savings)

2. Estrategias de caché

Evite volver a hacer scraping del mismo contenido implementando una caché inteligente.

Ejemplo de caché con Redis

Almacene los resultados en caché durante 24 horas para eliminar solicitudes duplicadas

Typescript
import Redis from 'ioredis';

const redis = new Redis(process.env.REDIS_URL!);

async function fetchWithCache(url: string) {
  // Try cache first
  const cacheKey = `scrape:${url}`;
  const cached = await redis.get(cacheKey);

  if (cached) {
    console.log('Cache hit! Saved 1 credit ✅');
    return JSON.parse(cached);
  }

  // Cache miss - scrape the URL
  console.log('Cache miss - scraping...');
  const response = await fetch('https://crawlforge.dev/api/v1/tools/fetch_url', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.CRAWLFORGE_API_KEY!,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ url }),
  });

  const data = await response.json();

  // Cache for 24 hours
  await redis.setex(cacheKey, 86400, JSON.stringify(data));

  return data;
}

// Usage
const data1 = await fetchWithCache('https://example.com'); // Uses 1 credit
const data2 = await fetchWithCache('https://example.com'); // Uses 0 credits (cached)
const data3 = await fetchWithCache('https://example.com'); // Uses 0 credits (cached)

// Savings: 2 credits (66% reduction)
Estrategia de TTL de caché: Contenido estático (24 h+), páginas de productos (6 h), noticias (1 h), datos en tiempo real (5 min o sin caché)

3. Solicitudes por lotes vs. individuales

Use el procesamiento por lotes para múltiples URL a fin de mejorar el rendimiento y reducir la sobrecarga.

  • Solicitudes individuales
    • ⏱️ Tiempo: ~5 segundos por URL
    • 💰 Costo: 1 credit por URL
    • 📊 Rendimiento: 12 URL/minuto
    • Úselo para: <10 URL
  • Solicitudes por lotes (recomendadas)
    • ⏱️ Tiempo: ~15 segundos para 50 URL
    • 💰 Costo: 1 credit por URL
    • 📊 Rendimiento: 200 URL/minuto
    • ✅ Úselo para: 10+ URL (¡16 veces más rápido!)

Comparación de código

Typescript
// Individual requests (SLOW)
const urls = [...]; // 50 URLs

const results = [];
for (const url of urls) {
  const response = await fetch('https://crawlforge.dev/api/v1/tools/fetch_url', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.CRAWLFORGE_API_KEY!,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ url }),
  });

  const data = await response.json();
  results.push(data);
}

// Time: ~250 seconds (4+ minutes)
// Cost: 50 credits

4. Análisis de costo/beneficio

Calcule el ROI de sus operaciones de scraping.

Plan Free
$0

1,000 credits de prueba por única vez — = 1,000 solicitudes de fetch_url

Plan Hobby
$19

5,000 credits — = $0.0038/credit

Professional
$99

50,000 credits — = $0.002/credit

Costo por cada 1,000 URL (plan Hobby)

  • ✅ Con fetch_url (1 credit): $3.80
  • ⚠️ Con scrape_structured (2 credits): $7.60
  • ❌ Con scrape_with_actions (5 credits): $19.00
  • ❌ Con deep_research (10 credits): $38.00

Resumen de optimización

  1. Comience siempre con fetch_url
  2. Almacene los resultados en caché durante al menos 1 hora
  3. Use batch_scrape para 10+ URL
  4. Evite deep_research para tareas sencillas
  5. Analice el HTML localmente cuando sea posible
  6. Use onlyMainContent: true para el scraping por lotes
  7. No haga scraping de la misma URL dos veces en 24 h
  8. Compruebe si el sitio tiene una API antes de hacer scraping
  9. Use webhooks para lotes grandes (100+ URL)
  10. Supervise el panel de uso semanalmente
¿Listo para optimizar?
Empiece a implementar estas estrategias para reducir los costos entre un 50 y un 80%
Ver referencia de la APIVer precios