E-commerce Use Cases

Product Data (Structured vs Text)

const apiKey = process.env.WEBLINQ_API_KEY;
const base = 'https://api.weblinq.dev/v1';

export async function extractProduct(url) {
  // minimal but useful schema
  const schema = {
    type: 'object',
    properties: {
      name: { type: 'string' },
      price: { type: 'number' },
      currency: { type: 'string' },
      availability: { type: 'string' },
    },
    required: ['name', 'price', 'availability'],
  };

  const {
    data: { extracted },
  } = await post('/web/ai-extract', {
    url,
    response_format: { type: 'json_schema', json_schema: schema },
  });

  return extracted;
}

function post(p, b) {
  return fetch(`${base}${p}`, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(b),
  }).then((r) => r.json());
}

const apiKey = process.env.WEBLINQ_API_KEY;
const base = 'https://api.weblinq.dev/v1';

export async function productInsights(url) {
  const {
    data: { text },
  } = await post('/web/ai-extract', {
    url,
    responseType: 'text', // ✅ matches schema
    prompt: `Analyse this product page and list key selling points, drawbacks and target audience.`,
  });

  return text;
}

function post(p, b) {
  /* same helper as above */
}

import requests, os, json
API  = 'https://api.weblinq.dev/v1'
KEY  = os.environ['WEBLINQ_API_KEY']

def extract_both(url):
    schema = { "type":"object",
               "properties":{"name":{"type":"string"},"price":{"type":"number"}},
               "required":["name","price"] }

    struct = req('/web/ai-extract', {
        "url": url,
        "response_format":{ "type":"json_schema","json_schema":schema }
    })['data']['extracted']

    text   = req('/web/ai-extract', {
        "url": url,
        "responseType":"text",
        "prompt":"Brief pros & cons."
    })['data']['text']

    return { "structured":struct, "analysis":text }

def req(path,payload):
    return requests.post(f'{API}{path}',
        headers={'Authorization':f'Bearer {KEY}','Content-Type':'application/json'},
        json=payload).json()

Competitor Store Snapshot

const apiKey = process.env.WEBLINQ_API_KEY;
const base = 'https://api.weblinq.dev/v1';

export async function snapshotStore(storeUrl) {
  // ① screenshot
  const shot = post('/web/screenshot', {
    url: storeUrl,
    screenshotOptions: { fullPage: true },
  });

  // ② internal links
  const links = post('/web/links', { url: storeUrl, includeExternal: false });

  // ③ quick store schema
  const schema = {
    type: 'object',
    properties: {
      storeName: { type: 'string' },
      totalProducts: { type: 'number' },
    },
  };

  const meta = post('/web/ai-extract', {
    url: storeUrl,
    response_format: { type: 'json_schema', json_schema: schema },
    prompt: 'Store overview',
  });

  const [screenshot, linkData, storeInfo] = await Promise.all([
    shot,
    links,
    meta,
  ]);

  const productLinks = (linkData.data.links || [])
    .filter((l) => /\/(product|item|p)\//.test(l.url))
    .slice(0, 20);

  return {
    url: storeUrl,
    screenshot: screenshot.data.permanentUrl,
    storeInfo: storeInfo.data.extracted,
    productLinks,
  };
}

function post(p, b) {
  return fetch(`${base}${p}`, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(b),
  }).then((r) => r.json());
}

Quick Price Report → PDF

const apiKey = process.env.WEBLINQ_API_KEY;
const base = 'https://api.weblinq.dev/v1';

export async function priceReport(urls) {
  const schema = {
    type: 'object',
    properties: {
      product: { type: 'string' },
      price: { type: 'number' },
      currency: { type: 'string' },
    },
    required: ['product', 'price', 'currency'],
  };

  const rows = await Promise.all(
    urls.map(async (url) => {
      const {
        data: { extracted },
      } = await post('/web/ai-extract', {
        url,
        response_format: { type: 'json_schema', json_schema: schema },
      });
      return { url, ...extracted };
    }),
  );

  const html = `
    <html><body><h1>Price Report</h1>
    <table border="1">${rows
      .map(
        (r) => `
      <tr><td>${r.product}</td><td>${r.currency}${r.price}</td><td>${r.url}</td></tr>`,
      )
      .join('')}
    </table></body></html>`;

  const dataUri =
    'data:text/html;base64,' + Buffer.from(html).toString('base64');

  const {
    data: { permanentUrl },
  } = await post('/web/pdf', { url: dataUri });

  return { rows, pdf: permanentUrl };
}

function post(p, b) {
  /* helper like above */
}

Product Discovery (Multi-Shop)

const apiKey = process.env.WEBLINQ_API_KEY;
const base = 'https://api.weblinq.dev/v1';

export async function findProducts(query, limit = 10) {
  const {
    data: { results },
  } = await post('/web/search', {
    query: `${query} site:amazon.com OR site:ebay.com OR site:walmart.com`,
    limit,
  });

  const schema = {
    type: 'object',
    properties: {
      name: { type: 'string' },
      price: { type: 'number' },
      currency: { type: 'string' },
    },
  };

  const products = await Promise.all(
    results.map((r) =>
      post('/web/ai-extract', {
        url: r.url,
        response_format: { type: 'json_schema', json_schema: schema },
      }).then((p) => ({
        platform: new URL(r.url).hostname,
        ...p.data.extracted,
      })),
    ),
  );

  return products.filter((p) => p.price).sort((a, b) => a.price - b.price);
}

function post(p, b) {
  /* helper */
}

Inventory Check (Stock Status)

const apiKey = process.env.WEBLINQ_API_KEY;
const base = 'https://api.weblinq.dev/v1';

export async function checkStock(urls) {
  const schema = {
    type: 'object',
    properties: {
      stockStatus: { type: 'string' },
      quantity: { type: 'number' },
    },
  };

  const items = await Promise.all(
    urls.map(async (url) => {
      const {
        data: { extracted },
      } = await post('/web/ai-extract', {
        url,
        response_format: { type: 'json_schema', json_schema: schema },
        prompt: 'Current stock status',
      });
      return { url, ...extracted };
    }),
  );

  return {
    items,
    outOfStock: items.filter((i) => i.stockStatus === 'out_of_stock').length,
  };
}

function post(p, b) {
  /* helper */
}

Key Features

🎯 JSON Schema Precision

Define exact data structures to extract consistent, structured product information every time.

🔍 Multi-API Workflows

Combine search, links, ai-extract, screenshot, and PDF APIs for comprehensive e-commerce intelligence.

📊 Competitive Analysis

Monitor competitor pricing, inventory, and promotions across multiple platforms automatically.

📈 Trend Tracking

Build historical datasets by regularly extracting product data and generating trend reports.

📊 When to Use JSON Schema

Consistent data structure needed across multiple products - Integration with databases or structured systems - Automated processing and comparison workflows - Data validation and quality assurance requirements

📝 When to Use Text Response

Flexible analysis and insights generation
Natural language summaries for human consumption
Creative content generation (reviews, descriptions)
Complex reasoning that doesn’t fit rigid structures

Always respect website terms of service and implement appropriate rate limiting when monitoring e-commerce sites.

Introduction

Guides

Product Data (Structured vs Text)

Competitor Store Snapshot

Quick Price Report → PDF

Product Discovery (Multi-Shop)

Inventory Check (Stock Status)

Key Features

​Product Data (Structured vs Text)

​Competitor Store Snapshot

​Quick Price Report → PDF

​Product Discovery (Multi-Shop)

​Inventory Check (Stock Status)

​Key Features

Product Data (Structured vs Text)

Competitor Store Snapshot

Quick Price Report → PDF

Product Discovery (Multi-Shop)

Inventory Check (Stock Status)

Key Features