Discover/Custom Lids API
live

Custom Lids APIcustomlids.com ↗

Search Custom Lids' hat catalog, get product details, retrieve site-wide pricing rules, and compute exact order prices for any configuration via 4 REST endpoints.

Endpoint health
verified 1h ago
search_products
get_product
get_pricing_rules
get_configuration_price
4/4 passing latest checkself-healing
Endpoints
4
Updated
2h ago

What is the Custom Lids API?

The Custom Lids API provides 4 endpoints covering product search, full product detail, site-wide pricing rules, and configuration-level price calculation for customlids.com's headwear catalog. The search_products endpoint returns paginated listings with brand, style, colorway, and price fields. The get_configuration_price endpoint computes an exact order total — including embroidery charges, patch options, quantity discounts, setup fee, and flat shipping — for any hat, quantity, and decoration combination.

This call costs1 credit / call— charged only on success
Try it
1-based page number.
Result ordering, one of the site's sort menu options.
Results per page, capped at 50.
Free-text search: product name, brand, or style/model words.
→ api.parse.bot/scraper/3db74724-06df-4547-8804-27eb87f53f52/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/3db74724-06df-4547-8804-27eb87f53f52/search_products?query=new+era+a-frame+9forty' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

Typed, relational, agent-ready

A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.

  • Fully typed · autocompletes
  • Objects link to objects
  • Typed errors & pagination

Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:

uv add parse-sdk
uv run parse init
uv run parse add --marketplace customlids-com-api

uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.

"""Walkthrough: Custom Lids SDK — search hats, inspect details, get a quote."""
from parse_apis.customlids_com_api import (
    CustomLids, SortOrder, DecorationMethod, InputNotFound,
)

client = CustomLids()

# Browse the catalog for snapback hats, capped at 5 results.
for hat in client.product_summaries.search(query="snapback", sort=SortOrder.BEST_SELLING, limit=5):
    print(hat.product_name, hat.brand, f"${hat.price}")

# Drill into the first matching product's full detail page.
summary = client.product_summaries.search(query="new era a-frame 9forty", limit=1).first()
if summary is not None:
    product = summary.details()
    print(product.product_name, product.color, product.available)
    print("Decoration methods:", product.decoration_methods)
    print("Thread colors:", product.thread_colors[:3])

    # Show available colorways for this product group.
    for color_opt in product.available_colors:
        print(f"  {color_opt.color}: ${color_opt.price} (in stock: {color_opt.available})")

    # Get a price quote: 12 embroidered hats with raised embroidery.
    quote = product.get_price(
        decoration_method=DecorationMethod.EMBROIDERY,
        quantity=12,
        embroidery_sides=2,
        raised_embroidery=True,
    )
    print(f"Unit price: ${quote.unit_discounted_price}  Total: ${quote.total_order_price}")
    print(f"Discount: {quote.quantity_discount_percent}% (tier {quote.quantity_tier})")
    for line in quote.decoration_line_items:
        print(f"  {line.item}: ${line.unit_price} x{line.quantity_per_hat}")

# Fetch a product directly by handle and catch a not-found error.
try:
    specific = client.products.get(product_handle="this-hat-does-not-exist")
except InputNotFound:
    print("Product not found — handle may be stale.")

# Read site-wide pricing rules (no inputs needed).
rules = client.pricing_rules.get()
print(f"Setup fee: ${rules.setup_fee} (waived from {rules.setup_fee_waived_from_quantity} units)")
for tier in rules.quantity_discounts:
    print(f"  {tier.quantity_range}: {tier.customized_discount_percent}% off customized")

print("exercised: product_summaries.search / details / products.get / get_price / pricing_rules.get")
All endpoints · 4 totalmissing one? ·

Searches the Custom Lids catalog by free text (product name, brand such as 'New Era', or style such as '9FORTY' or 'trucker') and returns one row per product listing (each colorway is a separate product with its own product_handle). Paginated through page and limit: page defaults to 1, limit defaults to 20 and is capped at 50; total_results is the site's total match count and has_more tells whether a further page exists. Only in-stock listings are returned. brand_style is the brand's style name (e.g. 9FORTY) when the site records it, otherwise null; color is taken from the listing title suffix. Pass product_handle to get_product or get_configuration_price.

Input
ParamTypeDescription
pageinteger1-based page number.
sortstringResult ordering, one of the site's sort menu options.
limitintegerResults per page, capped at 50.
queryrequiredstringFree-text search: product name, brand, or style/model words.
Response
{
  "type": "object",
  "fields": {
    "page": "page returned",
    "sort": "sort applied",
    "limit": "page size applied",
    "query": "echo of the search text",
    "has_more": "true when a later page exists",
    "products": "array of listings: product_id, product_handle, product_name, brand, brand_style, product_type, color, price (USD), price_max, compare_at_price (null when not on sale), available, sizes, inventory_quantity, patch_eligible, tags, image",
    "total_results": "total matching products on the site"
  },
  "sample": {
    "data": {
      "page": 1,
      "sort": "relevance",
      "limit": 5,
      "query": "new era a-frame 9forty",
      "has_more": true,
      "products": [
        {
          "tags": [
            "A-Frame",
            "adjustable",
            "hats",
            "New Era",
            "snapback"
          ],
          "brand": "New Era",
          "color": "Midnight Navy",
          "image": "https://cdn.shopify.com/s/files/1/0354/5271/5148/files/1000_2e260f0d-d5d4-4b54-87f9-6650e3f3bd0e.jpg?v=1770751147",
          "price": 31.99,
          "sizes": [
            "Adjustable"
          ],
          "available": true,
          "price_max": 31.99,
          "product_id": "7534656946372",
          "brand_style": "9FORTY",
          "product_name": "New Era A-Frame 9FORTY Snapback - Midnight Navy",
          "product_type": "Adjustable",
          "patch_eligible": true,
          "product_handle": "new-era-a-frame-9forty-snapback-navy",
          "compare_at_price": null,
          "inventory_quantity": 3125
        }
      ],
      "total_results": 7
    },
    "status": "success"
  }
}

About the Custom Lids API

Catalog Search and Product Detail

search_products accepts a free-text query (brand name, style number, or product keywords such as "New Era 9FORTY" or "trucker") and returns paginated results with fields including product_id, product_handle, brand, brand_style, color, price, and price_max. Each colorway is its own listing with a distinct product_handle, so a single hat model offered in six colors returns six rows. Use page and limit (capped at 50) to page through results; has_more indicates whether additional pages exist.

get_product takes a product_handle from search results and returns the full listing: variants (each with variant_id, size, sku, price, compare_at_price, available, and minimum_quantity), available_colors (sibling colorways with their own handles), images, tags, and the decoration methods the product supports — embroidery locations, patch types, and whether blank ordering is available.

Pricing Rules and Configuration Pricing

get_pricing_rules returns the complete site-wide customization fee schedule with no inputs required. Response fields include embroidery_prices (per-hat cost for first side and additional sides), premium_upgrades (raised embroidery, specialty thread), a quantity_discounts table with customized_discount_percent and blank_discount_percent per tier, setup_fee, setup_fee_waived_from_quantity, and shipping_rates broken down by quantity range.

get_configuration_price combines a product_handle, quantity, and decoration_method into a single priced output. For embroidery, pass embroidery_sides (1–3) and optionally specialty_thread: true. For patch, pass a patch_type code from the product's patch_types array and an optional patch_count (1–5). The response returns shipping, setup_fee, patch_type, variant_id, size, color, brand, and currency, giving a complete breakdown of what an order would cost before checkout.

Reliability & maintenanceVerified

The Custom Lids API is a managed, monitored endpoint for customlids.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when customlids.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.

This isn't an official customlids.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.

Last verified
1h ago
Latest check
4/4 endpoints passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Build a custom hat configurator that prices embroidery options in real time using get_configuration_price with varying embroidery_sides and specialty_thread values.
  • Aggregate New Era and comparable brand hat listings with color and price data from search_products for a headwear comparison tool.
  • Display quantity break pricing tables to wholesale buyers by pulling the quantity_discounts tiers from get_pricing_rules.
  • Populate a product catalog page with variant-level size, SKU, and availability data from get_product.
  • Compute total order cost for patch decoration by passing patch_type and patch_count to get_configuration_price and surfacing the flat shipping charge.
  • Identify sibling colorways for a hat style by reading available_colors from get_product and linking each to its own product_handle.
  • Check whether the setup fee applies to a specific order size by reading setup_fee_waived_from_quantity from get_pricing_rules.
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo2005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min
Team$300/mo20,000300 req/min
Company$1,000/mo100,000500 req/min

Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.

Frequently asked questions
Does Custom Lids have an official developer API?+
Custom Lids does not publish a public developer API. This Parse API provides structured access to their catalog and pricing data.
What does `get_product` return that `search_products` does not?+
search_products returns one summary row per colorway listing. get_product adds the full variants array (with per-size SKU, price, availability, and minimum quantity), the available_colors list of sibling colorways with their handles, images, tags, and the decoration methods and embroidery locations the product supports — data that is not present in search results.
Does the API return customer reviews or ratings for hats?+
Not currently. The API covers catalog data, variant/pricing details, decoration options, and order price calculation. You can fork it on Parse and revise to add a reviews endpoint if that data is available on product pages.
Can I retrieve orders or account information through this API?+
Not currently. The API is read-only and covers the public-facing product catalog and pricing rules. Order history and account data require authentication on the site and are not exposed. You can fork the API on Parse and revise it to add any additional endpoints you need.
How does pagination work in `search_products`, and is there a maximum page size?+
Results are paginated using the page parameter (1-based) and limit (results per page, capped at 50). The has_more field in the response is true when additional pages exist, and total_results reports the full count of matching products across all pages.
Page content last updated . Spec covers 4 endpoints from customlids.com.
Related APIs in EcommerceSee all →