Giant Bicycles APIgiant-bicycles.com ↗
Access Giant Bicycles US product data via API: bike specs, geometry, pricing, clearance listings, gear categories, and authorized dealer locations.
What is the Giant Bicycles API?
The Giant Bicycles API covers 7 endpoints that expose product catalog data, component specifications, and retail store locations from Giant Bicycles' US site. The get_bike_details endpoint returns full bike specs including frame geometry by size, variant part numbers, MSRP pricing, and product descriptions. Other endpoints handle category browsing, keyword search, clearance listings, gear navigation, and dealer lookup by zip code or city.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/54100d13-9565-42cf-b36c-6c6ba67aa1a6/list_bike_categories' \ -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 giant-bicycles-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: Giant Bicycles SDK — browse categories, search bikes, find stores."""
from parse_apis.giant_bicycles_api import GiantBicycles, BikeCategory_, BikeNotFound
client = GiantBicycles()
# List all bike categories and access one by enum
for cat in client.bikecategories.list(limit=6):
print(cat.name, cat.slug)
# Browse road bikes using a constructible category
road = client.bikecategory(slug=BikeCategory_.ROAD_BIKES)
for bike in road.bikes(limit=3):
print(bike.name, bike.price, bike.url)
# Search for a specific model and drill into details
result = client.searchresults.search(query="propel", limit=1).first()
if result:
print(result.name, result.type)
# Get bike details via a BikeSummary drill-down
summary = road.bikes(limit=1).first()
if summary:
try:
detail = summary.details()
print(detail.name, detail.price)
for variant in detail.variants[:2]:
print(variant.Color, variant.PartnumberCodes)
except BikeNotFound as exc:
print(f"Bike not found: {exc.url}")
# Find nearby retail stores
for dealer in client.dealers.find(keyword="San Francisco", limit=3):
print(dealer.Name, dealer.City, dealer.State, dealer.IsGiantStore)
# Check clearance deals
for deal in client.bikesummaries.clearance(limit=3):
print(deal.name, deal.price, deal.tags)
print("exercised: bikecategories.list / bikecategory.bikes / searchresults.search / summary.details / dealers.find / bikesummaries.clearance")
Returns the top-level bike categories available on the Giant Bicycles US site. Each category has a name, slug, and full URL. Use slugs with list_bikes_by_category to browse models within a category.
No input parameters required.
{
"type": "object",
"fields": {
"categories": "array of category objects with name, slug, and url"
},
"sample": {
"data": {
"categories": [
{
"url": "https://www.giant-bicycles.com/us/bikes/road-bikes",
"name": "Road Bikes",
"slug": "road-bikes"
},
{
"url": "https://www.giant-bicycles.com/us/bikes/mountain-bikes",
"name": "Mountain Bikes",
"slug": "mountain-bikes"
},
{
"url": "https://www.giant-bicycles.com/us/bikes/cross-and-gravel-bikes",
"name": "Cross & Gravel Bikes",
"slug": "cross-and-gravel-bikes"
},
{
"url": "https://www.giant-bicycles.com/us/bikes/fitness-and-city-bikes",
"name": "Fitness & City Bikes",
"slug": "fitness-and-city-bikes"
},
{
"url": "https://www.giant-bicycles.com/us/bikes/e-bikes",
"name": "E-bikes",
"slug": "e-bikes"
},
{
"url": "https://www.giant-bicycles.com/us/bikes/kids-bikes",
"name": "Kids Bikes",
"slug": "kids-bikes"
}
]
},
"status": "success"
}
}About the Giant Bicycles API
Catalog and Product Data
The list_bike_categories endpoint returns top-level category objects with name, slug, and url fields. Those slugs feed directly into list_bikes_by_category, which accepts a required category param and an optional subcategory param to narrow results. The response includes an array of bike objects — each with name, url, price, thumbnail, and tags — plus a total count. search_bikes accepts a free-text query string and returns matching products with name, url, and type fields.
Bike Detail and Specs
get_bike_details is the most data-dense endpoint. Pass a product URL path or slug (full https:// URLs are also accepted) and get back the bike's name, price, description, a specs object of key-value component pairs (groupset, drivetrain, wheels, etc.), a geometry array broken out by frame size, and a variants array with color images and part numbers. The product_id field is returned when available.
Clearance and Gear
list_clearance_bikes requires no inputs and returns all currently discounted models as an array of bike objects with name, url, price, and tags, plus a total. list_gear_categories returns the full gear navigation tree — accessories, clothing, and components — as category objects with name and url.
Retail Store Finder
find_retail_stores accepts a required keyword (city name or ZIP code) and optional lat/lng coordinates. The response includes a dealers array with each store's Name, City, State, Address, Phone, and coordinates, plus a campaigns array that distinguishes Giant Store, Partner Store, and Click & Collect locations. The filteredBy field reflects any active store-type filter.
The Giant Bicycles API is a managed, monitored endpoint for giant-bicycles.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when giant-bicycles.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 giant-bicycles.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?+
- Build a bike comparison tool using
get_bike_detailsgeometry and specs fields across multiple models. - Power a price-tracking app by polling
list_bikes_by_categoryand monitoring thepricefield for changes. - Surface clearance deals in a cycling deals aggregator using
list_clearance_bikes. - Add a dealer locator feature to a cycling app using
find_retail_storeswith ZIP code input. - Index Giant's full product catalog for a search engine using
list_bike_categoriesandlist_bikes_by_categorytogether. - Filter bikes by category and tag for a recommendation engine using
category,subcategory, andtagsfields. - Track gear accessory categories for a retail content site using
list_gear_categories.
| 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 Giant Bicycles offer an official developer API?+
What store information does `find_retail_stores` return, and does it show real-time inventory?+
Name, Address, City, State, Phone, coordinates, and store type (Giant Store, Partner Store, or Click & Collect) via the campaigns array. It does not return per-store inventory levels — only store locations and contact details are exposed.Does `get_bike_details` return geometry for all frame sizes?+
geometry field is an array of measurement objects broken out by size, so a single call covers all available frame sizes for a model. The exact set of measurements (reach, stack, top tube, etc.) depends on what Giant publishes for each model.