AI Data Extraction Examples

A pipeline that scrapes web pages, uses AI to identify and extract specific data points (prices, specifications, contact information), structures the output as JSON, and validates against expected schemas.

// AI web data extraction
async function extractFromWebPage(url, schema) {
  const html = await fetchPage(url);
  const cleanText = stripHTML(html);

  const extracted = await llm.chat({
    messages: [{
      role: "system",
      content: `Extract data matching this schema from the page content: ${JSON.stringify(schema)}. Return valid JSON.`
    }, { role: "user", content: cleanText }],
    responseFormat: { type: "json_object" }
  });

  // Validate against schema
  const validation = validateSchema(extracted, schema);
  if (!validation.valid) {
    return { data: extracted, errors: validation.errors, confidence: "low" };
  }

  return { data: extracted, confidence: "high" };
}

An image-based extraction system that processes photos of business cards, extracts contact details (name, title, company, phone, email, address), and creates structured contact records in the CRM.

// Business card extraction
async function extractBusinessCard(image) {
  const contact = await llm.chat({
    messages: [{
      role: "system",
      content: "Extract contact information from this business card image. Return JSON with: name, title, company, email, phone, address, website."
    }],
    images: [image],
    responseFormat: { type: "json_object" }
  });

  // Validate email format, phone number format
  const validated = validateContactFields(contact);

  // Check for duplicates in CRM
  const duplicate = await crm.findDuplicate(validated.email, validated.phone);

  return { contact: validated, isDuplicate: !!duplicate, existingRecord: duplicate };
}

Extracts line items, totals, and key ratios from financial statements (balance sheets, income statements, cash flow statements) in PDF format. Handles various layouts and formats from different reporting standards.

// Financial statement extraction
async function extractFinancials(pdfDocument) {
  const pages = await pdfToText(pdfDocument);

  const financials = await llm.chat({
    messages: [{
      role: "system",
      content: `Extract financial data from this statement. Return JSON with:
      - statementType (balance_sheet | income_statement | cash_flow)
      - period, currency
      - lineItems: [{ name, value, category }]
      - totals: { revenue, netIncome, totalAssets, etc. }`
    }, { role: "user", content: pages.join("\n") }],
    responseFormat: { type: "json_object" }
  });

  // Cross-validation: do the line items sum to the stated totals?
  const validated = crossValidateFinancials(financials);

  return { data: financials, validationErrors: validated.errors, confidence: validated.confidence };
}

Extracts structured candidate information from resumes in various formats (PDF, DOCX, plain text). Identifies skills, experience, education, and certifications regardless of layout or format variations.

// Resume parsing
async function parseResume(document) {
  const text = await extractText(document);

  const parsed = await llm.chat({
    messages: [{
      role: "system",
      content: `Parse this resume into structured data:
      { name, email, phone, location, summary,
        experience: [{ company, title, startDate, endDate, responsibilities[] }],
        education: [{ institution, degree, field, year }],
        skills: [], certifications: [] }`
    }, { role: "user", content: text }],
    responseFormat: { type: "json_object" }
  });

  // Normalise skills against taxonomy
  parsed.skills = normaliseSkills(parsed.skills);

  return parsed;
}

A pipeline that extracts related data from multiple sources (database, spreadsheets, PDFs, emails), reconciles discrepancies, and produces a unified dataset. Uses AI to resolve conflicts and fill gaps.

// Multi-source data reconciliation
async function reconcileData(sources) {
  // Extract from each source
  const datasets = await Promise.all(
    sources.map(async (source) => ({
      source: source.name,
      data: await extractFromSource(source),
    }))
  );

  // Find conflicts
  const conflicts = findConflicts(datasets);

  // Resolve conflicts with AI
  const resolutions = await Promise.all(
    conflicts.map(async (conflict) => {
      const resolution = await llm.chat({
        messages: [{
          role: "system",
          content: "Resolve this data conflict. Consider source reliability, recency, and consistency."
        }, { role: "user", content: JSON.stringify(conflict) }]
      });
      return { conflict, resolution, requiresReview: resolution.confidence < 0.8 };
    })
  );

  return { unified: mergeDatasets(datasets, resolutions), conflicts: resolutions };
}

Processes photos of receipts to extract merchant, date, items, amounts, tax, and total. Handles crumpled receipts, partial text, and various formats. Categorises expenses automatically based on merchant and items.

// Receipt extraction
async function extractReceipt(receiptImage) {
  const data = await llm.chat({
    messages: [{
      role: "system",
      content: `Extract receipt data. Return JSON:
      { merchant, date, items: [{ name, quantity, price }], subtotal, tax, total, currency, paymentMethod }
      If any field is unclear, set it to null.`
    }],
    images: [receiptImage],
    responseFormat: { type: "json_object" }
  });

  // Auto-categorise
  data.category = await categoriseExpense(data.merchant, data.items);

  // Validate totals
  const calculatedTotal = data.items.reduce((sum, i) => sum + i.price * i.quantity, 0);
  data.totalValidated = Math.abs(calculatedTotal - data.subtotal) < 0.01;

  return data;
}