Skip to content
Tabstack Tabstack Tabstack
Get started
SDKs
TypeScript
Generate Features

Generate Features

Use AI to transform and analyze web content with the Tabstack TypeScript SDK Generate operator.

The Generate operator uses AI to transform and analyze web content according to your instructions. Unlike Extract which pulls data as-is, Generate creates new insights, summaries, and transformations of the original content.

Overview

Section titled “Overview”

The generate operator is accessed through your Tabstack client instance:

import Tabstack from '@tabstack/sdk';


const client = new Tabstack({
  apiKey: process.env.TABSTACK_API_KEY!
});


// Access generate methods
client.generate.json({ url, json_schema, instructions });

When to Use Generate vs Extract

Section titled “When to Use Generate vs Extract”

Extract pulls data as it appears on the page:

// Extract: Get the exact price shown on the page
const result = await client.extract.json({ url, json_schema: priceSchema });
// Returns: { price: 99.99 }

Generate transforms and analyzes content with AI:

// Generate: Analyze pricing and create insights
const result = await client.generate.json({
  url,
  json_schema: analysisSchema,
  instructions: 'Analyze the pricing strategy and categorize it as budget, mid-range, or premium'
});
// Returns: { price: 99.99, category: "mid-range", analysis: "..." }

Generate JSON

Section titled “Generate JSON”

Transform web content into structured data using AI with custom instructions.

Basic Usage

Section titled “Basic Usage”
const schema = {
  type: 'object',
  properties: {
    summaries: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          title: { type: 'string' },
          category: { type: 'string' },
          summary: { type: 'string' }
        },
        required: ['title', 'category', 'summary']
      }
    }
  },
  required: ['summaries']
};


const result = await client.generate.json({
  url: 'https://news.ycombinator.com',
  json_schema: schema,
  instructions: 'For each story, categorize it (tech, business, science, etc.) and write a one-sentence summary'
});


console.log(result.summaries);

Example Output:

{
  "summaries": [
    {
      "title": "New AI Model Released",
      "category": "tech",
      "summary": "A breakthrough language model with improved reasoning capabilities was announced today."
    },
    {
      "title": "Database Performance Tips",
      "category": "tech",
      "summary": "Key strategies for optimizing database queries and indexing in production systems."
    }
  ]
}

Real-World Examples

Section titled “Real-World Examples”

Example 1: Sentiment Analysis

Section titled “Example 1: Sentiment Analysis”

Analyze the sentiment and tone of web content:

interface SentimentAnalysis {
  overallSentiment: 'positive' | 'negative' | 'neutral';
  confidence: number;
  keyPhrases: string[];
  emotionalTone: string;
  mainTopics: string[];
}


const schema = {
  type: 'object',
  properties: {
    overallSentiment: {
      type: 'string',
      enum: ['positive', 'negative', 'neutral']
    },
    confidence: {
      type: 'number',
      description: 'Confidence score from 0 to 1'
    },
    keyPhrases: {
      type: 'array',
      items: { type: 'string' },
      description: 'Important phrases that indicate sentiment'
    },
    emotionalTone: {
      type: 'string',
      description: 'Description of the emotional tone'
    },
    mainTopics: {
      type: 'array',
      items: { type: 'string' }
    }
  },
  required: ['overallSentiment', 'confidence']
};


const result = await client.generate.json({
  url: 'https://reviews.example.com/product/123',
  json_schema: schema,
  instructions: 'Analyze the overall sentiment of the product reviews, extract key phrases, and identify main topics discussed'
}) as SentimentAnalysis;


console.log(`Sentiment: ${result.overallSentiment} (${result.confidence * 100}% confident)`);
console.log(`Tone: ${result.emotionalTone}`);
console.log(`Key phrases: ${result.keyPhrases.join(', ')}`);
console.log(`Topics: ${result.mainTopics.join(', ')}`);

Example 2: Content Categorization and Tagging

Section titled “Example 2: Content Categorization and Tagging”

Automatically categorize and tag articles:

interface CategorizedArticle {
  title: string;
  primaryCategory: string;
  secondaryCategories: string[];
  tags: string[];
  targetAudience: string;
  readingLevel: 'beginner' | 'intermediate' | 'advanced';
  estimatedReadingTime: number;
}


const schema = {
  type: 'object',
  properties: {
    title: { type: 'string' },
    primaryCategory: {
      type: 'string',
      description: 'Main category (e.g., Technology, Business, Health)'
    },
    secondaryCategories: {
      type: 'array',
      items: { type: 'string' }
    },
    tags: {
      type: 'array',
      items: { type: 'string' },
      description: 'Relevant keywords and topics'
    },
    targetAudience: {
      type: 'string',
      description: 'Description of intended audience'
    },
    readingLevel: {
      type: 'string',
      enum: ['beginner', 'intermediate', 'advanced']
    },
    estimatedReadingTime: {
      type: 'number',
      description: 'Reading time in minutes'
    }
  },
  required: ['title', 'primaryCategory', 'tags', 'readingLevel']
};


const result = await client.generate.json({
  url: 'https://blog.example.com/article',
  json_schema: schema,
  instructions: 'Categorize this article, identify relevant tags, determine the target audience, assess reading difficulty, and estimate reading time'
}) as CategorizedArticle;


console.log(`Title: ${result.title}`);
console.log(`Category: ${result.primaryCategory}`);
console.log(`Level: ${result.readingLevel}`);
console.log(`Reading Time: ${result.estimatedReadingTime} minutes`);
console.log(`Tags: ${result.tags.join(', ')}`);

Example 3: Extract Key Insights

Section titled “Example 3: Extract Key Insights”

Pull out the most important information from long-form content:

interface ArticleInsights {
  mainThesis: string;
  keyPoints: string[];
  conclusions: string[];
  actionItems: string[];
  relevantQuotes: Array<{
    quote: string;
    context: string;
  }>;
}


const schema = {
  type: 'object',
  properties: {
    mainThesis: {
      type: 'string',
      description: 'The primary argument or purpose of the article'
    },
    keyPoints: {
      type: 'array',
      items: { type: 'string' },
      description: 'Main points supporting the thesis'
    },
    conclusions: {
      type: 'array',
      items: { type: 'string' },
      description: 'Key conclusions or takeaways'
    },
    actionItems: {
      type: 'array',
      items: { type: 'string' },
      description: 'Actionable recommendations'
    },
    relevantQuotes: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          quote: { type: 'string' },
          context: { type: 'string' }
        }
      }
    }
  },
  required: ['mainThesis', 'keyPoints', 'conclusions']
};


const result = await client.generate.json({
  url: 'https://research.example.com/paper',
  json_schema: schema,
  instructions: 'Extract the main thesis, key supporting points, conclusions, and actionable recommendations. Include 2-3 relevant quotes with context.'
}) as ArticleInsights;


console.log('Main Thesis:');
console.log(result.mainThesis);
console.log('\nKey Points:');
result.keyPoints.forEach((point, i) => {
  console.log(`${i + 1}. ${point}`);
});
console.log('\nAction Items:');
result.actionItems.forEach((item, i) => {
  console.log(`${i + 1}. ${item}`);
});

Example 4: Comparative Analysis

Section titled “Example 4: Comparative Analysis”

Compare multiple items and generate insights:

interface ProductComparison {
  products: Array<{
    name: string;
    price: number;
    pros: string[];
    cons: string[];
    bestFor: string;
  }>;
  recommendation: string;
  valueLeader: string;
  premiumChoice: string;
}


const schema = {
  type: 'object',
  properties: {
    products: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          name: { type: 'string' },
          price: { type: 'number' },
          pros: { type: 'array', items: { type: 'string' } },
          cons: { type: 'array', items: { type: 'string' } },
          bestFor: {
            type: 'string',
            description: 'Type of user or use case'
          }
        }
      }
    },
    recommendation: {
      type: 'string',
      description: 'Overall recommendation based on comparison'
    },
    valueLeader: { type: 'string' },
    premiumChoice: { type: 'string' }
  },
  required: ['products', 'recommendation']
};


const result = await client.generate.json({
  url: 'https://reviews.example.com/laptop-comparison',
  json_schema: schema,
  instructions: 'Compare the laptops, list pros and cons for each, identify who each is best for, and provide an overall recommendation. Identify the value leader and premium choice.'
}) as ProductComparison;


console.log('Comparison Summary:');
console.log(result.recommendation);
console.log(`\nBest Value: ${result.valueLeader}`);
console.log(`Premium Choice: ${result.premiumChoice}`);


result.products.forEach(product => {
  console.log(`\n${product.name} - $${product.price}`);
  console.log(`Best for: ${product.bestFor}`);
  console.log(`Pros: ${product.pros.join(', ')}`);
  console.log(`Cons: ${product.cons.join(', ')}`);
});

Writing Effective Instructions

Section titled “Writing Effective Instructions”

The quality of your results depends heavily on your instructions. Here are best practices:

Be Specific and Clear

Section titled “Be Specific and Clear”
// Vague
'Analyze this content'


// Specific
'Analyze the sentiment of customer reviews, categorize each as positive/negative/neutral, and extract common themes'

Define Expected Output

Section titled “Define Expected Output”
// Unclear output
'Summarize the articles'


// Clear expectations
'For each article, write a 2-sentence summary focusing on the main finding and its practical implications'

Include Context

Section titled “Include Context”
// No context
'Extract information'


// With context
'You are analyzing product reviews for a purchasing decision. Extract the most mentioned pros and cons, and identify any dealbreaker issues.'

Use Examples When Helpful

Section titled “Use Examples When Helpful”
const instructions = `
Categorize each product review as positive, negative, or mixed.
Examples:
- "Great product, works perfectly!" → positive
- "Terrible quality, broke after one week" → negative
- "Good features but poor battery life" → mixed
`;

Options Reference

Section titled “Options Reference”

GenerateJsonOptions

Section titled “GenerateJsonOptions”
OptionTypeDefaultDescription
urlstring-The URL to generate content from
json_schemaobject-JSON schema defining the output structure
instructionsstring-Instructions for the AI to follow
geoTarget{ country: string }-Geotargeting parameters for region-specific content (e.g., { country: 'GB' })
nocachebooleanfalseBypass cache and force fresh generation

Combining Generate with Extract

Section titled “Combining Generate with Extract”

You can combine Extract and Generate for powerful workflows:

// Step 1: Extract raw data
const extractSchema = {
  type: 'object',
  properties: {
    products: {
      type: 'array',
      items: {
        type: 'object',
        properties: {
          name: { type: 'string' },
          price: { type: 'number' },
          description: { type: 'string' }
        }
      }
    }
  }
};


const extracted = await client.extract.json({ url, json_schema: extractSchema });


// Step 2: Generate insights from extracted data
const generateSchema = {
  type: 'object',
  properties: {
    analysis: {
      type: 'object',
      properties: {
        priceRange: { type: 'string' },
        averagePrice: { type: 'number' },
        productCategories: { type: 'array', items: { type: 'string' } },
        recommendations: { type: 'array', items: { type: 'string' } }
      }
    }
  }
};


const generated = await client.generate.json({
  url,
  json_schema: generateSchema,
  instructions: 'Analyze the product lineup, determine price ranges, categorize products, and provide purchasing recommendations'
});


console.log('Product Analysis:', generated.analysis);

Best Practices

Section titled “Best Practices”

1. Use Descriptive Schema Properties

Section titled “1. Use Descriptive Schema Properties”

Include description fields to guide the AI:

const schema = {
  type: 'object',
  properties: {
    sentiment: {
      type: 'string',
      enum: ['positive', 'negative', 'neutral'],
      description: 'Overall sentiment based on tone and language used'
    },
    confidence: {
      type: 'number',
      description: 'Confidence level from 0 to 1, where 1 is very confident'
    }
  }
};

2. Be Mindful of Costs

Section titled “2. Be Mindful of Costs”

Generate operations use AI and are more expensive than Extract. Use them when you need analysis, not just data extraction.

// Good: Use Extract for straightforward data
const prices = await client.extract.json({ url, json_schema: priceSchema });


// Wasteful: Using Generate when Extract would work
const prices = await client.generate.json({
  url,
  json_schema: priceSchema,
  instructions: 'Get the prices'
});

3. Test Instructions Iteratively

Section titled “3. Test Instructions Iteratively”

Start simple and refine based on results:

// Iteration 1: Basic
'Summarize the article'


// Iteration 2: More specific
'Summarize the article in 3 sentences, focusing on key findings'


// Iteration 3: Optimized
'Summarize the article in 3 sentences. Focus on: 1) main finding, 2) methodology, 3) practical implications for developers'

4. Handle Variable Content

Section titled “4. Handle Variable Content”

Account for pages that might not have all expected content:

const schema = {
  type: 'object',
  properties: {
    sentiment: { type: 'string' },
    keyPoints: {
      type: 'array',
      items: { type: 'string' },
      description: 'Main points if present; empty array if none found'
    }
  }
};

Next Steps

Section titled “Next Steps”