> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nimbleway.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Gallery

> Browse Nimble's catalog of pre-built extraction templates

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](/nimble-sdk/web-tools/extract/quickstart) to pull structured data from any URL.

<CardGroup cols={2}>
  <Card icon="bullseye-pointer" href="/nimble-sdk/web-tools/extract/template" title="Use Templates">
    Learn how to call templates from your code, no CSS selectors required
  </Card>

  <Card icon="plug" href="/integrations/agent-skills/plugin-installation" title="Install Plugin">
    Let Claude Code or Cursor find the right template for you automatically
  </Card>
</CardGroup>

<Card title="Browse Templates Visually" icon="palette" href="https://online.nimbleway.com/pipeline-gallery">
  Explore pre-built templates with previews, examples, and interactive
  documentation.
</Card>

### 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

<Note>
  Prefer a visual interface? Browse templates with previews, live demos, and
  exportable code snippets at the [visual
  gallery](https://online.nimbleway.com/pipeline-gallery) in Nimble Platform.
</Note>

***

## List Templates

Browse and search the template catalog.

<Card icon="code" title="GET /v2/extract/templates">
  `GET https://sdk.nimbleway.com/v2/extract/templates`
</Card>

### 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

<CodeGroup>
  ```python Python theme={"system"}
  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}")
  ```

  ```javascript Node theme={"system"}
  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}`);
  });
  ```

  ```bash cURL theme={"system"}
  curl -X GET 'https://sdk.nimbleway.com/v2/extract/templates?privacy=public' \
    -H 'Authorization: Bearer YOUR-API-KEY'
  ```
</CodeGroup>

### Response Example

```json theme={"system"}
[
  {
    "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.

<Card icon="code" title="GET /v2/extract/templates/{extract_template_name}">
  ```GET https://sdk.nimbleway.com/v2/extract/templates/{extract_template_name} theme={"system"}
  ```
</Card>

### 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

<CodeGroup>
  ```python Python theme={"system"}
  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)}")
  ```

  ```javascript Node theme={"system"}
  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(", ")}`);
    }
  });
  ```

  ```bash cURL theme={"system"}
  curl -X GET 'https://sdk.nimbleway.com/v2/extract/templates/amazon_pdp' \
    -H 'Authorization: Bearer YOUR-API-KEY'
  ```
</CodeGroup>

### Response Example

```json theme={"system"}
{
  "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](http://www.amazon.com) | Yes | No |
| `amazon_serp` | Amazon Search | [www.amazon.com](http://www.amazon.com) | Yes | Yes |
| `amazon_category` | Amazon Category | [www.amazon.com](http://www.amazon.com) | No | Yes |
| `walmart_pdp` | Walmart Product Page | [www.walmart.com](http://www.walmart.com) | Yes | No |
| `walmart_search` | Walmart Search | [www.walmart.com](http://www.walmart.com) | Yes | Yes |
| `target_pdp` | Target Product Page | [www.target.com](http://www.target.com) | Yes | No |
| `best_buy_pdp` | Best Buy Product | [www.bestbuy.com](http://www.bestbuy.com) | Yes | No |
| `home_depot_pdp` | Home Depot Product | [www.homedepot.com](http://www.homedepot.com) | Yes | No |

### Search Engines

| Template | Display Name | Domain | Localization | Pagination |
| - | - | - | - | - |
| `google_search` | Google Search Results | [www.google.com](http://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](http://www.google.com) | Yes | No |

### Social Media

| Template | Display Name | Domain | Localization | Pagination |
| - | - | - | - | - |
| `tiktok_account` | TikTok Account | [www.tiktok.com](http://www.tiktok.com) | No | Yes |
| `facebook_page` | Facebook Page | [www.facebook.com](http://www.facebook.com) | No | No |
| `youtube_shorts` | YouTube Shorts | [www.youtube.com](http://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](http://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`:

<CodeGroup>
  ```python Python theme={"system"}
  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})")
  ```

  ```javascript Node theme={"system"}
  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})`);
  });
  ```

  ```bash cURL theme={"system"}
  curl -X GET 'https://sdk.nimbleway.com/v2/extract/templates?search=amazon' \
    -H 'Authorization: Bearer YOUR-API-KEY'
  ```
</CodeGroup>

### Filter Templates by Vertical

Find all templates for a specific industry:

```python theme={"system"}
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:

```python theme={"system"}
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:

```python theme={"system"}
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:

```python theme={"system"}
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

<CardGroup cols={2}>
  <Card title="Extract" icon="arrows-to-circle" href="/nimble-sdk/web-tools/extract/quickstart">
    Pull structured data from any URL with full control
  </Card>

  <Card title="Install Plugin" icon="plug" href="/integrations/agent-skills/plugin-installation">
    Use Nimble in Claude Code or Cursor
  </Card>

  <Card title="Use Templates" icon="play" href="/nimble-sdk/web-tools/extract/template">
    Learn how to call templates in your code
  </Card>

  <Card icon="code" href="/api-reference/extract-templates-api/list-extract-templates" title="API Reference">
    Explore endpoints and response schemas for the Extract Templates API
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.