Gallery - Nimble Docs

The Gallery is Nimble’s catalog of pre-built extraction templates for popular websites. These templates are maintained by Nimble 24/7 and auto-heal when sites change. Don’t see the site you need? Use Extract to pull structured data from any URL.

Use Templates

Learn how to call templates from your code, no CSS selectors required

Install Plugin

Let Claude Code or Cursor find the right template for you automatically

Browse Templates Visually

Explore pre-built templates with previews, examples, and interactive documentation.

When to Use

Use template discovery when you need to:

Browse available templates - See what platforms are supported
Filter by vertical - Find templates for specific industries (e-commerce, search, social)
Inspect template details - Understand input parameters and output schema
Check capabilities - Verify localization and pagination support

Two Ways to Explore

Prefer a visual interface? Browse templates with previews, live demos, and exportable code snippets at the visual gallery in Nimble Platform.

List Templates

Browse and search the template catalog.

GET /v2/extract/templates

GET https://sdk.nimbleway.com/v2/extract/templates

Parameters

Parameter	Type	Description	Required
`privacy`	Enum	Filter by privacy level (`all`, `public`, `private`)	No
`search`	String	Filter templates by keyword.	No
`offset`	Integer	Pagination offset (default: `0`)	No
`limit`	Integer	Number of results per page (default: `100`)	No

Response Schema

Each template in the response contains:

Field	Type	Description
`name`	string	Unique template identifier (use this in API calls)
`display_name`	string	Human-readable template name
`description`	string	What the template extracts
`is_public`	boolean	Whether the template is publicly available
`managed_by`	string	Who maintains this template: `nimble` (public), `community` (public), or `self` (private)
`vertical`	string	Industry vertical (e.g., “Ecommerce”, “Search”)
`entity_type`	string	Page type (e.g., “Product Detail Page”, “SERP”)
`domain`	string	Target website domain

Usage Examples

from nimble_python import Nimble

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

# List all public templates
templates = nimble.extract.templates.list(privacy="public")

for template in templates:
    print(f"{template.name}: {template.display_name}")
    print(f"  Domain: {template.domain}")
    print(f"  Vertical: {template.vertical}")
    print(f"  Type: {template.entity_type}")

import Nimble from "@nimble-way/nimble-js";

const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });

// List all public templates
const templates = await nimble.extract.templates.list({ privacy: "public" });

templates.forEach((template) => {
  console.log(`${template.name}: ${template.display_name}`);
  console.log(`  Domain: ${template.domain}`);
  console.log(`  Vertical: ${template.vertical}`);
  console.log(`  Type: ${template.entity_type}`);
});

curl -X GET 'https://sdk.nimbleway.com/v2/extract/templates?privacy=public' \
  -H 'Authorization: Bearer YOUR-API-KEY'

Response Example

[
  {
    "name": "amazon_pdp",
    "is_public": true,
    "display_name": "Amazon Product Page",
    "description": "Extract structured data from Amazon product detail pages including pricing, reviews, specifications, and availability.",
    "vertical": "Ecommerce",
    "entity_type": "Product Detail Page (PDP)",
    "domain": "www.amazon.com"
  },
  {
    "name": "amazon_serp",
    "is_public": true,
    "display_name": "Amazon Search Results",
    "description": "Extract product listings from Amazon search results pages based on a keyword query.",
    "vertical": "Ecommerce",
    "entity_type": "Search Engine Results Page (SERP)",
    "domain": "www.amazon.com"
  },
  {
    "name": "walmart_pdp",
    "is_public": true,
    "display_name": "Walmart Product Page",
    "description": "Extract structured data from Walmart product detail pages including pricing, reviews, and variants.",
    "vertical": "Ecommerce",
    "entity_type": "Product Detail Page (PDP)",
    "domain": "www.walmart.com"
  },
  {
    "name": "google_search",
    "is_public": true,
    "display_name": "Google Search Results",
    "description": "Extract structured data from Google Search Results Pages (SERPs) including organic results, ads, and featured snippets.",
    "vertical": "Search Engine",
    "entity_type": "Search Engine Results Page (SERP)",
    "domain": "www.google.com"
  }
]

Get Template Details

Get comprehensive information about a specific template, including input parameters and output schema.

GET /v2/extract/templates/{extract_template_name}

https://sdk.nimbleway.com/v2/extract/templates/{extract_template_name}

Parameters

Parameter	Type	Description	Required
`extract_template_name`	string	The template name (e.g., `amazon_pdp`)	Yes

Response Schema

Field	Type	Description
`name`	string	Unique template identifier
`display_name`	string	Human-readable template name
`description`	string	What the template extracts
`is_public`	boolean	Whether the template is publicly available
`managed_by`	string	Who maintains this template: `nimble` (public), `community` (public), or `self` (private)
`vertical`	string	Industry vertical
`entity_type`	string	Page type
`domain`	string	Target website domain
`input_properties`	array	Input parameters for the template (see below)
`output_schema`	object	JSON schema describing output fields
`feature_flags`	object	Supported capabilities (localization, pagination)

Input Properties

Each item in input_properties contains:

Field	Type	Description
`name`	string	Parameter name
`type`	string	Data type (string, number, boolean)
`description`	string	What the parameter does
`required`	boolean	Whether the parameter is required
`default`	string	Default value if not provided
`examples`	array	Example values
`rules`	array	Validation rules
`is_localization_param`	boolean	Whether the parameter controls localization
`is_pagination_param`	boolean	Whether the parameter controls pagination

Feature Flags

Flag	Type	Description
`is_localization_supported`	boolean	Supports ZIP code for location-specific data
`is_pagination_supported`	boolean	Supports paginated results

Usage Examples

from nimble_python import Nimble

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

# Get template details
template = nimble.extract.templates.get("amazon_pdp")

print(f"Template: {template.display_name}")
print(f"Description: {template.description}")
print(f"Domain: {template.domain}")

# Check feature flags
flags = template.feature_flags
print(f"\nCapabilities:")
print(f"  Localization: {'Yes' if flags.is_localization_supported else 'No'}")
print(f"  Pagination: {'Yes' if flags.is_pagination_supported else 'No'}")

# List input parameters
print(f"\nInput Parameters:")
for param in template.input_properties:
    required = "required" if param.required else "optional"
    print(f"  {param.name} ({param.type}) - {required}")
    print(f"    {param.description}")
    if param.examples:
        print(f"    Examples: {', '.join(param.examples)}")

import Nimble from "@nimble-way/nimble-js";

const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });

// Get template details
const template = await nimble.extract.templates.get("amazon_pdp");

console.log(`Template: ${template.display_name}`);
console.log(`Description: ${template.description}`);
console.log(`Domain: ${template.domain}`);

// Check feature flags
const flags = template.feature_flags;
console.log("\nCapabilities:");
console.log(
  `  Localization: ${flags.is_localization_supported ? "Yes" : "No"}`,
);
console.log(`  Pagination: ${flags.is_pagination_supported ? "Yes" : "No"}`);

// List input parameters
console.log("\nInput Parameters:");
template.input_properties.forEach((param) => {
  const required = param.required ? "required" : "optional";
  console.log(`  ${param.name} (${param.type}) - ${required}`);
  console.log(`    ${param.description}`);
  if (param.examples?.length) {
    console.log(`    Examples: ${param.examples.join(", ")}`);
  }
});

curl -X GET 'https://sdk.nimbleway.com/v2/extract/templates/amazon_pdp' \
  -H 'Authorization: Bearer YOUR-API-KEY'

Response Example

{
  "name": "amazon_pdp",
  "is_public": true,
  "display_name": "Amazon Product Page",
  "description": "Extract structured data from Amazon product detail pages including pricing, reviews, specifications, variants, and availability.",
  "vertical": "Ecommerce",
  "entity_type": "Product Detail Page (PDP)",
  "domain": "www.amazon.com",
  "input_properties": [
    {
      "name": "asin",
      "required": true,
      "type": "string",
      "description": "Amazon Standard Identification Number (ASIN) - the unique 10-character product identifier",
      "rules": ["Must be exactly 10 alphanumeric characters"],
      "examples": ["B08N5WRWNW", "B0DLKFK6LR"],
      "default": null
    },
    {
      "name": "zip_code",
      "required": false,
      "type": "string",
      "description": "ZIP code for location-specific pricing and availability",
      "rules": ["5-digit US ZIP code"],
      "examples": ["90210", "10001"],
      "default": "90210"
    }
  ],
  "output_schema": {
    "asin": { "type": "string", "description": "Product ASIN" },
    "product_title": { "type": "string", "description": "Full product name" },
    "brand": { "type": "string", "description": "Product brand" },
    "web_price": { "type": "number", "description": "Current selling price" },
    "list_price": {
      "type": "number",
      "description": "Original price before discount"
    },
    "average_of_reviews": {
      "type": "number",
      "description": "Average rating (0-5)"
    },
    "number_of_reviews": {
      "type": "number",
      "description": "Total review count"
    },
    "availability": { "type": "boolean", "description": "Whether in stock" },
    "image_url": { "type": "string", "description": "Main product image URL" }
  },
  "feature_flags": {
    "is_localization_supported": true,
    "is_pagination_supported": false
  }
}

Available Templates by Vertical

E-commerce

Template	Display Name	Domain	Localization	Pagination
`amazon_pdp`	Amazon Product Page	www.amazon.com	Yes	No
`amazon_serp`	Amazon Search	www.amazon.com	Yes	Yes
`amazon_category`	Amazon Category	www.amazon.com	No	Yes
`walmart_pdp`	Walmart Product Page	www.walmart.com	Yes	No
`walmart_search`	Walmart Search	www.walmart.com	Yes	Yes
`target_pdp`	Target Product Page	www.target.com	Yes	No
`best_buy_pdp`	Best Buy Product	www.bestbuy.com	Yes	No
`home_depot_pdp`	Home Depot Product	www.homedepot.com	Yes	No

Search Engines

Template	Display Name	Domain	Localization	Pagination
`google_search`	Google Search Results	www.google.com	Yes	Yes
`google_maps_search`	Google Maps Search	maps.google.com	Yes	Yes
`google_search_aio`	Google AI Overview	www.google.com	Yes	No

Template	Display Name	Domain	Localization	Pagination
`tiktok_account`	TikTok Account	www.tiktok.com	No	Yes
`facebook_page`	Facebook Page	www.facebook.com	No	No
`youtube_shorts`	YouTube Shorts	www.youtube.com	No	Yes

LLM Platforms

Template	Display Name	Domain	Localization	Pagination
`chatgpt`	ChatGPT Responses	chatgpt.com	No	No
`gemini`	Gemini Responses	gemini.google.com	No	No
`perplexity`	Perplexity	www.perplexity.ai	No	No
`grok`	Grok Responses	grok.com	No	No

Common Patterns

Search Templates by Keyword

Use the search query parameter to find templates matching a term across display_name, vertical, and domain:

from nimble_python import Nimble

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

templates = nimble.extract.templates.list(search="amazon")

for template in templates:
    print(f"{template.name}: {template.display_name} ({template.domain})")

import Nimble from "@nimble-way/nimble-js";

const nimble = new Nimble({ apiKey: "YOUR-API-KEY" });

const templates = await nimble.extract.templates.list({ search: "amazon" });

templates.forEach((template) => {
  console.log(`${template.name}: ${template.display_name} (${template.domain})`);
});

curl -X GET 'https://sdk.nimbleway.com/v2/extract/templates?search=amazon' \
  -H 'Authorization: Bearer YOUR-API-KEY'

Filter Templates by Vertical

Find all templates for a specific industry:

from nimble_python import Nimble

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

# Get all templates
templates = nimble.extract.templates.list(privacy="public")

# Filter by vertical
ecommerce_templates = [
    template for template in templates
    if template.vertical == 'Ecommerce'
]

print(f"Found {len(ecommerce_templates)} e-commerce templates:")
for template in ecommerce_templates:
    print(f"  {template.name}: {template.display_name} ({template.domain})")

Check Localization Support

Verify a template supports location-specific data:

from nimble_python import Nimble

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

template = nimble.extract.templates.get("amazon_pdp")

if template.feature_flags.is_localization_supported:
    print("This template supports localization!")
    print("Pass zip_code parameter for location-specific pricing.")
else:
    print("This template does not support localization.")

Get Required Parameters

Find which parameters are required before running a template:

from nimble_python import Nimble

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

template = nimble.extract.templates.get("amazon_pdp")

required_params = [
    p for p in template.input_properties
    if p.required
]

optional_params = [
    p for p in template.input_properties
    if not p.required
]

print("Required parameters:")
for p in required_params:
    examples = ', '.join(p.examples) if p.examples else ''
    print(f"  {p.name}: {p.description}")
    if examples:
        print(f"    Examples: {examples}")

print("\nOptional parameters:")
for p in optional_params:
    default = p.default if p.default else 'none'
    print(f"  {p.name}: {p.description} (default: {default})")

Validate Parameters Before Calling

Check parameters match the expected schema:

from nimble_python import Nimble

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

def validate_params(template_name, params):
    """Validate params against template input_properties"""
    template = nimble.extract.templates.get(template_name)
    errors = []

    # Build lookup of input properties
    props = {p.name: p for p in template.input_properties}

    # Check required fields
    for prop_name, prop in props.items():
        if prop.required and prop_name not in params:
            errors.append(f"Missing required parameter: {prop_name}")

    # Check for unknown parameters
    for param_name in params:
        if param_name not in props:
            errors.append(f"Unknown parameter: {param_name}")

    return errors

# Validate before calling
errors = validate_params("amazon_pdp", {"asin": "B08N5WRWNW"})

if errors:
    print("Validation errors:")
    for error in errors:
        print(f"  - {error}")
else:
    print("Parameters are valid!")

Next Steps

Extract

Pull structured data from any URL with full control

Install Plugin

Use Nimble in Claude Code or Cursor

Use Templates

Learn how to call templates in your code

API Reference

Explore endpoints and response schemas for the Extract Templates API

Use Templates

Install Plugin

Browse Templates Visually

​When to Use

​Two Ways to Explore

​List Templates

GET /v2/extract/templates

​Parameters

​Response Schema

​Usage Examples

​Response Example

​Get Template Details

GET /v2/extract/templates/{extract_template_name}

​Parameters

​Response Schema

​Input Properties

​Feature Flags

​Usage Examples

​Response Example

​Available Templates by Vertical

​E-commerce

​Search Engines

​Social Media

​LLM Platforms

​Common Patterns

​Search Templates by Keyword

​Filter Templates by Vertical

​Check Localization Support

​Get Required Parameters

​Validate Parameters Before Calling

​Next Steps

Extract

Install Plugin

Use Templates

API Reference

When to Use

Two Ways to Explore

List Templates

Parameters

Response Schema

Usage Examples

Response Example

Get Template Details

Parameters

Response Schema

Input Properties

Feature Flags

Usage Examples

Response Example

Available Templates by Vertical

E-commerce

Search Engines

Social Media

LLM Platforms

Common Patterns

Search Templates by Keyword

Filter Templates by Vertical

Check Localization Support

Get Required Parameters

Validate Parameters Before Calling

Next Steps