IGGM APIiggm.com ↗
Retrieve item listings and normalized unit prices from the IGGM Grow A Garden 2 marketplace. Paginated or full-catalog access via 2 endpoints.
What is the IGGM API?
The IGGM Grow A Garden 2 API exposes 2 endpoints for retrieving item listings and their unit prices from the IGGM marketplace. The get_items_page endpoint returns up to 30 items per page including name and unit_price, while get_all_items collapses all pages into a single response containing every listed item alongside total_items and total_pages counts. Bulk pack listings such as 'Gold Seed×100' are automatically divided down to a per-unit price before being returned.
curl -X GET 'https://api.parse.bot/scraper/eda63677-17bc-4378-8a78-66fb2db24dc4/get_items_page?page=1' \ -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 iggm-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: IGGM Grow A Garden 2 Items SDK — browse, paginate, and fetch all items."""
from parse_apis.iggm_com_api import GrowAGarden2, ParseError
client = GrowAGarden2()
# List items from the first page with auto-pagination, capped at 5
for item in client.items.list(limit=5):
print(item.name, f"${item.unit_price:.4f}")
# Fetch all items in one call (internally iterates all pages)
all_items = client.items.list_all(limit=10)
first_item = all_items.first()
if first_item:
print(f"First item: {first_item.name} at ${first_item.unit_price:.4f}")
# Handle errors gracefully
try:
for item in client.items.list(limit=3):
print(item.name, item.unit_price)
except ParseError as exc:
print(f"Error fetching items: {exc}")
print("exercised: items.list / items.list_all / error handling")
Fetch a single page of Grow A Garden 2 items with their unit prices. Each page contains up to 30 items. Bulk listings (e.g. 'Gold Seed×100') are normalized to their per-unit price. Results are auto-iterated across pages.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number to fetch (1-based). |
{
"type": "object",
"fields": {
"page": "integer",
"items": "array of item objects with name and unit_price",
"total_pages": "integer"
},
"sample": {
"data": {
"page": 1,
"items": [
{
"name": "Ghost Pepper Pack",
"unit_price": 0.79
},
{
"name": "Unicorn",
"unit_price": 1.18
},
{
"name": "Gold Seed",
"unit_price": 0.0342
}
],
"total_pages": 5
},
"status": "success"
}
}About the IGGM API
Endpoints and Response Shape
The API provides two endpoints covering the Grow A Garden 2 section of the IGGM marketplace. get_items_page accepts an optional page integer (1-based) and returns a page number, a total_pages count, and an items array where each object carries a name string and a unit_price value. Each page contains up to 30 items. If you omit the page parameter the endpoint defaults to the first page.
Full Catalog Retrieval
get_all_items takes no input parameters and internally iterates every page, returning a flat items array alongside total_items and total_pages. This saves you from writing your own pagination loop and is the straightforward choice when you need a complete price snapshot of the Grow A Garden 2 catalog in one call.
Bulk Listing Normalization
Many IGGM listings are sold in multiples — for example a bundle labeled '×100'. Both endpoints normalize these automatically: the price is divided by the pack quantity before being stored in unit_price. This means every item in the response is directly comparable regardless of how the original listing was bundled, without any extra arithmetic on your side.
Coverage Scope
The API is scoped specifically to the Grow A Garden 2 category on iggm.com. It returns item names and unit prices; it does not currently expose seller identity, stock quantity, listing age, or other marketplace metadata that may appear on the source pages.
The IGGM API is a managed, monitored endpoint for iggm.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when iggm.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 iggm.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?+
- Track unit price movements for specific Grow A Garden 2 items over time by polling
get_all_itemson a schedule - Build a price comparison table for the full catalog using the flat
itemsarray fromget_all_items - Identify the cheapest items in the catalog by sorting the
unit_pricefield across all returned objects - Paginate through new listings incrementally using
get_items_pagewith an incrementingpageparameter - Alert users when a target item's
unit_pricedrops below a threshold by diffing successive snapshots - Normalize bulk vs. single-unit listings for fair price analysis without manual quantity division
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 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.
Does IGGM have an official developer API?+
What does the `unit_price` field represent for bulk listings?+
unit_price is the total listing price divided by that quantity. Both get_items_page and get_all_items apply this normalization before returning data, so the field always represents the cost of a single unit regardless of how the seller packaged the listing.How many items does each page from `get_items_page` contain?+
total_pages so you can calculate how many requests are needed to cover the full catalog. If you want all items in one call, get_all_items handles the iteration for you.Does the API return seller details, stock levels, or listing timestamps?+
name and unit_price fields only. Seller identity, available stock quantity, listing age, and other per-listing metadata are not included in the current response shape. You can fork this API on Parse and revise it to add those fields if they are available from the source.