How to Sell a Web Scraping API in 2026:
Developer Revenue Guide

// src/scraper.ts
import { chromium, Browser, Page } from 'playwright';

interface SERPResult {
  position: number;
  title: string;
  url: string;
  snippet: string;
  domain: string;
}

interface ScrapeResult {
  query: string;
  country: string;
  results: SERPResult[];
  scrapedAt: string;
}

// Proxies.sx mobile proxy configuration
const PROXY_CONFIG = {
  host: 'gate.proxies.sx',
  port: 5432,
  username: process.env.PROXIES_USER!,
  password: process.env.PROXIES_PASS!,
};

export async function scrapeGoogle(
  query: string,
  country: string = 'US'
): Promise<ScrapeResult> {
  let browser: Browser | null = null;

  try {
    // Launch with mobile proxy (real 4G/5G IP)
    browser = await chromium.launch({
      proxy: {
        server: `http://${PROXY_CONFIG.host}:${PROXY_CONFIG.port}`,
        username: `${PROXY_CONFIG.username}-country-${country}`,
        password: PROXY_CONFIG.password,
      },
    });

    const page: Page = await browser.newPage({
      userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) '
        + 'AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 '
        + 'Mobile/15E148 Safari/604.1',
      viewport: { width: 390, height: 844 },
    });

    // Navigate to Google with country-specific TLD
    const tld = country === 'US' ? 'com' : country.toLowerCase();
    await page.goto(
      `https://www.google.${tld}/search?q=${encodeURIComponent(query)}&hl=en`,
      { waitUntil: 'domcontentloaded', timeout: 30000 }
    );

    // Parse organic results
    const results: SERPResult[] = await page.evaluate(() => {
      const items = document.querySelectorAll('#search .g');
      return Array.from(items).slice(0, 10).map((el, i) => {
        const titleEl = el.querySelector('h3');
        const linkEl = el.querySelector('a');
        const snippetEl = el.querySelector('[data-sncf]') || el.querySelector('.VwiC3b');
        const url = linkEl?.getAttribute('href') || '';
        return {
          position: i + 1,
          title: titleEl?.textContent || '',
          url,
          snippet: snippetEl?.textContent || '',
          domain: url ? new URL(url).hostname : '',
        };
      });
    });

    return {
      query,
      country,
      results,
      scrapedAt: new Date().toISOString(),
    };
  } finally {
    if (browser) await browser.close();
  }
}

// src/index.ts
import { Hono } from 'hono';
import { cors } from 'hono/cors';
import { scrapeGoogle } from './scraper';

const app = new Hono();

// CORS for browser clients
app.use('/*', cors());

// Health check (free, no payment needed)
app.get('/', (c) => {
  return c.json({
    service: 'SERP Scraping API',
    version: '1.0.0',
    pricing: '$0.005 per search query (USDC via x402)',
    docs: 'https://your-api.com/docs',
    endpoints: {
      '/api/serp': 'Google SERP scraping (GET)',
    },
  });
});

// SERP scraping endpoint
app.get('/api/serp', async (c) => {
  const query = c.req.query('q');
  const country = c.req.query('country') || 'US';

  if (!query) {
    return c.json({ error: 'Missing required parameter: q' }, 400);
  }

  try {
    const result = await scrapeGoogle(query, country);
    return c.json(result);
  } catch (error) {
    return c.json(
      { error: 'Scraping failed', message: (error as Error).message },
      500
    );
  }
});

export default app;

// src/index.ts (with x402 payment gating)
import { Hono } from 'hono';
import { cors } from 'hono/cors';
import { x402Middleware } from '@proxies-sx/x402-hono';
import { verifySolanaPayment } from '@proxies-sx/x402-solana';
import { scrapeGoogle } from './scraper';

const app = new Hono();
app.use('/*', cors());

// Free health/discovery endpoint (no payment)
app.get('/', (c) => {
  return c.json({
    service: 'SERP Scraping API',
    version: '1.0.0',
    pricing: '$0.005 per request (USDC via x402)',
    networks: ['solana', 'base'],
    endpoints: { '/api/serp': 'GET - Google SERP scraping' },
  });
});

// x402 payment gate: $0.005 per request
app.use('/api/*', x402Middleware({
  price: 5000,          // $0.005 in micro-units (1 unit = $0.000001)
  recipient: 'YOUR_SOLANA_WALLET_ADDRESS',
  verify: verifySolanaPayment,
  networks: ['solana', 'base'],  // Accept both networks
  description: 'Google SERP scraping - 10 organic results per query',
}));

// Paid endpoint: scrape Google SERPs
app.get('/api/serp', async (c) => {
  const query = c.req.query('q');
  const country = c.req.query('country') || 'US';

  if (!query) {
    return c.json({ error: 'Missing required parameter: q' }, 400);
  }

  const result = await scrapeGoogle(query, country);
  return c.json(result);
});

export default app;

# Install the Proxies.sx x402 SDK packages
npm install @proxies-sx/x402-core @proxies-sx/x402-hono @proxies-sx/x402-solana

# Install the scraping stack
npm install hono playwright

# Optional: cache layer
npm install @upstash/redis

// src/cache.ts
import { Redis } from '@upstash/redis';

const redis = Redis.fromEnv();
const CACHE_TTL = 3600; // 1 hour in seconds

export async function getCachedResult(key: string) {
  const cached = await redis.get<string>(key);
  if (cached) return JSON.parse(cached);
  return null;
}

export async function setCachedResult(key: string, data: unknown) {
  await redis.set(key, JSON.stringify(data), { ex: CACHE_TTL });
}

// In your API handler:
app.get('/api/serp', async (c) => {
  const query = c.req.query('q')!;
  const country = c.req.query('country') || 'US';
  const cacheKey = `serp:${country}:${query.toLowerCase()}`;

  // Check cache first (no proxy cost)
  const cached = await getCachedResult(cacheKey);
  if (cached) {
    return c.json({ ...cached, cached: true });
  }

  // Scrape fresh data (costs proxy bandwidth)
  const result = await scrapeGoogle(query, country);
  await setCachedResult(cacheKey, result);
  return c.json(result);
});