Structify: From Chaos to Structure in Seconds

Start with a simple flat schema for straightforward extraction

{
  "name": "string",
  "email": "string",
  "phone": "string",
  "company": "string",
  "role": "string"
}

Input: Input text: ''Hi, I''m Sarah Johnson from TechCorp (sarah.j@techcorp.com, +1-555-0123). I''m the VP of Engineering.''

Output: Output: '{'name: ''Sarah Johnson'', email: ''sarah.j@techcorp.com'', phone: ''+1-555-0123'', company: ''TechCorp'', role: ''VP of Engineering'''}'

Specify exact types for better validation and type safety

{
  "invoice_number": "string",
  "date": "date",
  "total_amount": "number",
  "currency": "string",
  "is_paid": "boolean",
  "line_items": "array",
  "vendor": {
    "name": "string",
    "address": "string",
    "tax_id": "string"
  }
}

Extract hierarchical data with nested objects

{
  "product": {
    "name": "string",
    "sku": "string",
    "price": {
      "amount": "number",
      "currency": "string",
      "tax_included": "boolean"
    },
    "availability": {
      "in_stock": "boolean",
      "quantity": "number",
      "warehouse": "string"
    },
    "specifications": {
      "dimensions": "string",
      "weight": "number",
      "color": "string"
    }
  }
}

Nested schemas keep related data organized and make downstream processing easier.

Extract lists and collections from text

{ "tags": ["string"], "prices": ["number"] }

{
  "line_items": [
    {
      "description": "string",
      "quantity": "number",
      "unit_price": "number",
      "total": "number"
    }
  ]
}

Perfect for invoices, shopping carts, multi-item forms, and product lists.

Mark fields as optional when they might not appear in all documents

{
  "name": "string",          // Required
  "email": "string",         // Required
  "phone?": "string",        // Optional
  "company?": "string",      // Optional
  "role?": "string"          // Optional
}

Use `?` suffix or specify `required: false` in JSON Schema format.

Implement business logic validation after extraction

const result = await structifyAPI.extract(text, schema);

// Custom validation
if (result.total_amount < 0) {
  throw new ValidationError('Total amount cannot be negative');
}

if (result.line_items.length === 0) {
  throw new ValidationError('Invoice must have at least one line item');
}

const calculatedTotal = result.line_items
  .reduce((sum, item) => sum + item.total, 0);

if (Math.abs(calculatedTotal - result.total_amount) > 0.01) {
  throw new ValidationError('Line items do not match total amount');
}

Process multiple documents efficiently

async function batchStructify(documents, schema) {
  const results = [];
  const errors = [];
  
  // Process in parallel (batch size: 10)
  for (let i = 0; i < documents.length; i += 10) {
    const batch = documents.slice(i, i + 10);
    
    const promises = batch.map(async (doc) => {
      try {
        const result = await structifyAPI.extract(doc.text, schema);
        return { id: doc.id, data: result, status: 'success' };
      } catch (error) {
        return { id: doc.id, error: error.message, status: 'failed' };
      }
    });
    
    const batchResults = await Promise.allSettled(promises);
    
    batchResults.forEach(result => {
      if (result.status === 'fulfilled') {
        if (result.value.status === 'success') {
          results.push(result.value);
        } else {
          errors.push(result.value);
        }
      }
    });
  }
  
  return { results, errors };
}

Process 1000 documents in 15 minutes instead of 3+ hours sequentially

Handle temporary errors gracefully

async function extractWithRetry(text, schema, maxRetries = 3) {
  let lastError;
  
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await structifyAPI.extract(text, schema);
    } catch (error) {
      lastError = error;
      
      // Retry only on transient errors
      if (error.code === 'RATE_LIMIT' || error.code === 'TIMEOUT') {
        const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      
      // Don't retry validation errors
      throw error;
    }
  }
  
  throw lastError;
}

Implement exponential backoff: 2s, 4s, 8s delays between retries

Validate extraction quality before downstream use

function validateExtraction(result, rules) {
  const issues = [];
  
  // Completeness check
  if (!result.email || !result.name) {
    issues.push('Missing required fields');
  }
  
  // Format validation
  if (result.email && !isValidEmail(result.email)) {
    issues.push('Invalid email format');
  }
  
  // Range validation
  if (result.price && result.price < 0) {
    issues.push('Price cannot be negative');
  }
  
  return { valid: issues.length === 0, issues };
}

Flag low-quality extractions for manual review instead of using bad data

Cache extraction results to save points and improve performance

Hash input text + schema → Cache key

const crypto = require('crypto');

function getCacheKey(text, schema) {
  const hash = crypto.createHash('sha256');
  hash.update(text + JSON.stringify(schema));
  return hash.digest('hex');
}

async function extractWithCache(text, schema) {
  const cacheKey = getCacheKey(text, schema);
  
  // Check cache
  const cached = await cache.get(cacheKey);
  if (cached) return JSON.parse(cached);
  
  // Extract
  const result = await structifyAPI.extract(text, schema);
  
  // Cache for 24 hours
  await cache.set(cacheKey, JSON.stringify(result), 86400);
  
  return result;
}

Save 70% of points on repeated extractions, 10x faster response times

Track extraction quality and performance

Alert on: success rate < 95%, extraction time > 10s, daily points > budget

Extract: name, email, phone, experience, education, skills

Validate: email format, phone format, required fields present

Process: 500 resumes in under 20 minutes

Quality: 95%+ success rate, flag incomplete records for review