Skip to main content
The Templates Discovery APIs help you find and understand available templates before using them. Browse templates by category, search by keyword, and inspect detailed schemas to understand inputs and outputs.

​
When to use

Use template discovery when you need to:
  • Browse available templates: See what platforms are supported
  • Filter by category: Find templates for specific industries
  • Search by keyword: Locate templates for specific platforms
  • Inspect template details: Understand input requirements and output structure
  • Validate before use: Check supported countries and rate limits

​
Two ways to explore templates

You can discover templates through the Platform UI or programmatically via API.

​
Via Platform UI

Browse templates visually with previews, examples, and interactive documentation.

Explore Template Gallery

Browse 150+ pre-built templates with visual previews and documentation
 Benefits:
  • Visual interface with template previews
  • Interactive documentation with examples
  • Try templates with sample inputs
  • Copy-paste ready code snippets

​
Via API

Programmatically discover and inspect templates for automation and integration. Benefits:
  • Build dynamic template selectors
  • Validate inputs before extraction
  • Generate forms from schemas
  • Compare template capabilities

​
Discovery APIs

​
List Templates

Browse and search the template catalog: 
GET https://api.webit.live/api/v1/extract-template

​
Get Template Details

Get comprehensive information about a specific template: 
GET https://api.webit.live/api/v1/extract-template/{template_name}

​
List Templates API

​
Parameters

ParameterTypeDescriptionRequired
categoryStringFilter by category (ecommerce, social, search, etc.)No
searchStringSearch templates by name or descriptionNo
pageIntegerPage number (default: 1)No
limitIntegerResults per page (default: 20, max: 100)No

​
Usage

​
List all templates

Get all available templates: 
from nimble import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

# Get first page of templates
templates = nimble.list_templates(
    page=1,
    limit=20
)

print(f"Total templates: {templates['total']}")
for template in templates["items"]:
    print(f"- {template['name']}: {template['description']}")

​
Filter by category

Get templates for a specific category: 
from nimble import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

# Get all e-commerce templates
templates = nimble.list_templates(
    category="ecommerce",
    limit=50
)

for template in templates["items"]:
    print(f"{template['name']} - {template['domain']}")

​
Search templates

Find templates by keyword: 
from nimble import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

# Search for Amazon templates
templates = nimble.list_templates(
    search="amazon"
)

for template in templates["items"]:
    print(f"{template['name']}: {template['description']}")

​
List response example

{
  "status": "success",
  "data": {
    "items": [
      {
        "name": "amazon_product",
        "description": "Extract detailed product information from Amazon",
        "category": "ecommerce",
        "domain": "amazon.com",
        "supported_countries": ["US", "UK", "DE", "FR", "IT", "ES", "CA"],
        "features": ["pricing", "reviews", "availability", "images"],
        "rate_limit": 100
      },
      {
        "name": "amazon_search",
        "description": "Search Amazon and get product listings",
        "category": "ecommerce",
        "domain": "amazon.com",
        "supported_countries": ["US", "UK", "DE", "FR", "IT", "ES", "CA"],
        "features": ["search_results", "sponsored_ads", "filters"],
        "rate_limit": 100
      }
    ],
    "pagination": {
      "page": 1,
      "limit": 20,
      "total": 156,
      "total_pages": 8
    }
  }
}

​
Get Template Details API

​
Parameters

ParameterTypeDescriptionRequired
template_nameStringThe name of the template (e.g., “amazon_product”)Yes

​
Usage

​
Get template details

Retrieve full information for a specific template: 
from nimble import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

# Get details for amazon_product template
template = nimble.get_template("amazon_product")

print(f"Template: {template['name']}")
print(f"Description: {template['description']}")
print(f"Domain: {template['domain']}")
print(f"Category: {template['category']}")
print(f"Rate limit: {template['rate_limit']} requests/minute")

​
Inspect input schema

Review required and optional inputs: 
from nimble import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

template = nimble.get_template("amazon_product")

# Review input schema
print("Required inputs:")
for field_name, field_info in template["input_schema"].items():
    if field_info.get("required"):
        print(f"  - {field_name}: {field_info['type']} - {field_info['description']}")

print("\nOptional inputs:")
for field_name, field_info in template["input_schema"].items():
    if not field_info.get("required"):
        print(f"  - {field_name}: {field_info['type']} - {field_info['description']}")

​
Review output schema

Understand what data you’ll receive: 
from nimble import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

template = nimble.get_template("amazon_product")

# Review output schema
print("Output fields:")
for field_name, field_info in template["output_schema"].items():
    print(f"  - {field_name}: {field_info['type']} - {field_info['description']}")

​
Check supported countries

Verify geographic availability: 
from nimble import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

template = nimble.get_template("amazon_product")

# Check supported countries
print(f"Supported countries: {', '.join(template['supported_countries'])}")

# Verify specific country
if "US" in template['supported_countries']:
    print("✓ US is supported")
else:
    print("✗ US is not supported")

​
Details response example

{
  "status": "success",
  "data": {
    "name": "amazon_product",
    "description": "Extract detailed product information from Amazon",
    "category": "ecommerce",
    "domain": "amazon.com",
    "supported_countries": ["US", "UK", "DE", "FR", "IT", "ES", "CA", "JP", "AU"],
    "rate_limit": 100,
    "input_schema": {
      "asin": {
        "type": "string",
        "description": "Amazon Standard Identification Number (10 alphanumeric characters)",
        "required": true,
        "pattern": "^[A-Z0-9]{10}$",
        "example": "B08N5WRWNW"
      },
      "country": {
        "type": "string",
        "description": "Target country code (e.g., US, UK, DE)",
        "required": false,
        "default": "US",
        "enum": ["US", "UK", "DE", "FR", "IT", "ES", "CA", "JP", "AU"]
      },
      "zipcode": {
        "type": "string",
        "description": "ZIP code for pricing and availability (US only)",
        "required": false,
        "example": "90210"
      }
    },
    "output_schema": {
      "asin": {
        "type": "string",
        "description": "Product ASIN"
      },
      "title": {
        "type": "string",
        "description": "Product title"
      },
      "price": {
        "type": "object",
        "description": "Pricing information",
        "properties": {
          "current": {
            "type": "number",
            "description": "Current price"
          },
          "original": {
            "type": "number",
            "description": "Original price (before discount)"
          },
          "currency": {
            "type": "string",
            "description": "Currency code (USD, EUR, etc.)"
          }
        }
      },
      "rating": {
        "type": "number",
        "description": "Average customer rating (0-5)"
      },
      "reviews_count": {
        "type": "integer",
        "description": "Total number of reviews"
      },
      "availability": {
        "type": "string",
        "description": "Stock availability status"
      },
      "images": {
        "type": "array",
        "description": "Product image URLs"
      }
    },
    "features": ["pricing", "reviews", "availability", "images", "seller_info"],
    "version": "2.1.0",
    "last_updated": "2026-01-05T10:30:00Z"
  }
}

​
Available categories

Filter templates by these categories:
CategoryDescriptionExample Templates
ecommerceOnline shopping platformsamazon_product, walmart_search, ebay_listing
professionalCareer and business networkslinkedin_profile, glassdoor_reviews, indeed_jobs
searchSearch enginesgoogle_search, bing_search, google_maps
socialSocial media platformstwitter_profile, instagram_posts, facebook_page
real-estateProperty listingszillow_listing, realtor_search, redfin_property
newsNews and media sitescnn_article, bbc_news, reuters_story
travelTravel and hospitalitybooking_hotel, airbnb_listing, expedia_search
financeFinancial datayahoo_finance_stock, bloomberg_quote, marketwatch

​
Use cases

​
Build dynamic forms

Generate input forms based on template schema: 
from nimble import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

def generate_form_fields(template_name):
    """Generate form fields from template input schema"""
    template = nimble.get_template(template_name)

    form_fields = []
    for field_name, field_info in template["input_schema"].items():
        form_fields.append({
            "name": field_name,
            "type": field_info["type"],
            "label": field_info["description"],
            "required": field_info.get("required", False),
            "default": field_info.get("default"),
            "options": field_info.get("enum"),
            "placeholder": field_info.get("example")
        })

    return form_fields

# Use in UI
fields = generate_form_fields("amazon_product")
for field in fields:
    print(f"{field['label']}: {field['name']} ({'required' if field['required'] else 'optional'})")

​
Validate inputs

Check inputs against template schema before execution: 
from nimble import Nimble
import re

nimble = Nimble(api_key="YOUR-API-KEY")

def validate_inputs(template_name, inputs):
    """Validate inputs against template schema"""
    template = nimble.get_template(template_name)
    errors = []

    # Check required fields
    for field_name, field_info in template["input_schema"].items():
        if field_info.get("required") and field_name not in inputs:
            errors.append(f"Missing required field: {field_name}")

    # Validate patterns
    for field_name, value in inputs.items():
        field_info = template["input_schema"].get(field_name, {})
        pattern = field_info.get("pattern")
        if pattern and not re.match(pattern, value):
            errors.append(f"Invalid format for {field_name}: {value}")

    return errors

# Validate before extraction
errors = validate_inputs("amazon_product", {
    "asin": "B08N5WRWNW",
    "country": "US"
})

if errors:
    print("Validation errors:")
    for error in errors:
        print(f"  - {error}")
else:
    print("✓ All inputs valid")

​
Compare templates

Evaluate multiple templates for your use case: 
from nimble import Nimble

nimble = Nimble(api_key="YOUR-API-KEY")

def compare_templates(template_names):
    """Compare capabilities of multiple templates"""
    comparison = []

    for name in template_names:
        template = nimble.get_template(name)
        comparison.append({
            "name": name,
            "description": template["description"],
            "inputs": len(template["input_schema"]),
            "outputs": len(template["output_schema"]),
            "countries": len(template["supported_countries"]),
            "rate_limit": template["rate_limit"]
        })

    return comparison

# Compare e-commerce templates
templates = compare_templates([
    "amazon_product",
    "walmart_product",
    "ebay_product"
])

for t in templates:
    print(f"{t['name']}: {t['inputs']} inputs, {t['outputs']} outputs, {t['countries']} countries")

​
Best practices

​
Cache template information

Reduce API calls by caching template data: 
import time

class TemplateCache:
    def __init__(self, nimble_client, ttl=86400):  # 24 hour default
        self.client = nimble_client
        self.ttl = ttl
        self.cache = {}
        self.last_update = {}

    def get_template(self, template_name):
        # Check cache validity
        if (template_name in self.cache and
            time.time() - self.last_update[template_name] < self.ttl):
            return self.cache[template_name]

        # Fetch and cache
        template = self.client.get_template(template_name)
        self.cache[template_name] = template
        self.last_update[template_name] = time.time()

        return template

​
Error handling

Handle API errors gracefully: 
try:
    template = nimble.get_template("amazon_product")
except TemplateNotFoundError:
    print("Template doesn't exist")
except APIError as e:
    print(f"API error: {e.message}")

​
Efficient pagination

Fetch all templates efficiently: 
def get_all_templates(nimble_client, category=None):
    """Get all templates with automatic pagination"""
    all_templates = []
    page = 1

    while True:
        response = nimble_client.list_templates(
            category=category,
            page=page,
            limit=100
        )

        all_templates.extend(response["items"])

        # Check if there are more pages
        if page >= response["pagination"]["total_pages"]:
            break

        page += 1

    return all_templates