The North Face APIthenorthface.com ↗
Access The North Face product catalog, real-time inventory, pricing, and category navigation via 5 structured API endpoints. No scraping required.
What is the The North Face API?
This API exposes 5 endpoints covering The North Face's full product catalog, from keyword search and category browsing to per-variant inventory levels. The get_product_detail endpoint alone returns over a dozen fields including feature lists, color/size attributes, and all purchasable variants with stock status. Pair it with get_product_inventory to get real-time inStock flags and maximum available quantities for every size and color combination of any style ID.
curl -X GET 'https://api.parse.bot/scraper/c9951d81-b2c1-4195-971e-02a83c30da83/search_products?sort=bestMatches&count=5&query=jacket&start=0' \ -H 'X-API-Key: $PARSE_API_KEY'
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 thenorthface-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.
"""The North Face Product API — search, browse categories, get details + inventory."""
from parse_apis.the_north_face_product_api import NorthFace, Sort, ProductNotFound
client = NorthFace()
# Search for jackets sorted by price, capped at 3 results
for product in client.products.search(query="fleece", sort=Sort.PRICE_LOW_TO_HIGH, limit=3):
print(product.name, product.price.current, product.rating.score)
# Drill into the first search result for full details
product = client.products.search(query="backpack", limit=1).first()
if product:
detail = product.details()
print(detail.name, detail.description[:80] if detail.description else "")
for variant in detail.variants[:2]:
print(variant.attributes.size, variant.stock.product_inventory_state, variant.price.current)
# Check real-time inventory on a known product
nuptse = client.product(id="NF0A3C8D")
inv = nuptse.inventory()
for v in inv.variants[:3]:
print(v.attributes.color, v.attributes.size, v.stock.in_stock, v.stock.max_qty)
# Browse a category by ID (Men's Jackets & Vests)
for item in client.products.by_category(category_id="211702", limit=3):
print(item.name, item.price.current)
# Typed error handling — catch product-not-found
try:
bad = client.product(id="INVALID123").details()
except ProductNotFound as exc:
print(f"Not found: {exc.style_id}")
# Get the navigation menu
menu = client.menus.get()
print(menu.name, len(menu.children), "top-level sections")
print("exercised: products.search / product.details / product.inventory / products.by_category / menus.get")
Full-text search over The North Face product catalog. Returns paginated product listings with pricing, ratings, and color swatches. Supports sorting and filter strings. The upstream API requires a minimum count of 5.
| Param | Type | Description |
|---|---|---|
| sort | string | Sort option for results. |
| count | integer | Number of results per page (minimum 5) |
| queryrequired | string | Search keyword (e.g. 'jacket', 'fleece', 'backpack') |
| start | integer | Offset for pagination |
| filters | string | Filter string using pipe-separated field:value pairs (e.g. 'colorFamily:Black') |
{
"type": "object",
"fields": {
"items": "integer number of products returned in this page",
"total": "integer total number of matching products",
"products": "array of product objects with id, styleId, name, slug, rating, images, price, color_swatches"
},
"sample": {
"data": {
"items": 5,
"total": 277,
"products": [
{
"id": "NF0A7QAW",
"name": "Men’s Alta Vista Jacket",
"slug": "/p/shop-all/jackets-701295/mens-alta-vista-jacket-NF0A7QAW",
"price": {
"current": 160,
"currency": "USD",
"discount": 0,
"original": 160
},
"images": "https://assets.thenorthface.com/images/t_Thumbnail/v1733349062/NF0A7QAWD1R-HERO/Mens-Alta-Vista-Jacket-TNF-HERO.png",
"rating": {
"score": 4.6,
"numReviews": 346
},
"styleId": "NF0A7QAW",
"color_swatches": [
{
"name": "Smoked Pearl",
"value": "4GU",
"colorHexCode": "66666B",
"variationGroupId": "NF0A7QAW4GU"
}
]
}
]
},
"status": "success"
}
}About the The North Face API
Product Search and Category Browsing
The search_products endpoint accepts a query string (e.g. 'jacket', 'fleece') and returns a paginated list of matching products. Each product object includes id, styleId, name, slug, rating, images, price, and color_swatches. Pagination is controlled via start (offset) and count (minimum 5 per page). Results can be sorted by bestMatches, priceLowToHigh, priceHighToLow, or newest, and filtered using a pipe-delimited filters string such as 'price:0-100|colorFamily:Black'.
The get_category_products endpoint works similarly but scopes results to a specific category. It accepts either a full slug like 'mens-jackets-and-vests-211702' or just the trailing numeric ID '211702'. To discover valid category IDs without guessing, use get_category_listing, which returns the complete global navigation tree — including all Men's, Women's, Kids, and Bags & Gear hierarchies — with categoryId, title, and url for every node.
Product Detail and Inventory
get_product_detail takes a style_id (e.g. 'NF0A3C8D') and optionally a color code to narrow variant data. The response includes a full description, an array of features strings, a rating object with score and numReviews, and a variants array where each entry carries its own price, stock, and attributes covering color, size, and fitType. The attributes array also lists all available options per attribute code, making it straightforward to build a size/color selector.
get_product_inventory accepts the same style_id and returns one entry per variant with inStock boolean, maxQty, and productInventoryState string. This endpoint is useful when you only need availability data and want to avoid fetching the full detail payload — for instance, when polling a watchlist of styles for restock events.
The The North Face API is a managed, monitored endpoint for thenorthface.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when thenorthface.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 thenorthface.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.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Monitor real-time restock events by polling
get_product_inventoryfor out-of-stock size/color variants usingproductInventoryState - Build a price comparison tool using
search_productswithpriceLowToHighsort and thepricefield on each product object - Sync a product feed to an external database using
get_category_productspaginated across all category IDs fromget_category_listing - Generate size availability grids for a buying guide by reading
variants[].attributesfromget_product_detail - Track color availability across a product line by filtering
get_product_detailresponses bycolorcode - Build a navigation sitemap by walking the hierarchical
childrentree returned byget_category_listing - Aggregate average rating and review counts across a category using the
rating.scoreandrating.numReviewsfields
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does The North Face have an official public developer API?+
What does `get_product_inventory` return that `get_product_detail` doesn't already cover?+
get_product_detail includes variant stock data as part of a larger payload that also fetches descriptions, feature lists, images, and attributes. get_product_inventory returns only the inventory fields — inStock, maxQty, and productInventoryState — for every variant of a style. Use it when you need availability data alone and want a smaller, faster response, such as polling a list of styles for restock.How does pagination work across `search_products` and `get_category_products`?+
start (zero-based offset) and count (items per page, minimum 5) parameters. The response includes a total field with the full match count, so you can calculate the number of pages needed and iterate with increasing start values.Does the API return customer review text or Q&A content?+
score and numReviews — but individual review text, reviewer details, and Q&A threads are not exposed. You can fork this API on Parse and revise it to add an endpoint covering per-product review content.Can I filter search results by size, not just price and color?+
filters parameter on search_products documents examples using price and colorFamily segments. Size-based filtering via the same parameter is not documented in the current spec. You can fork this API on Parse and revise the search endpoint to add size filter support once you identify the correct filter key.