Org APIgbgb.org.uk ↗
Access greyhound race results, meeting details, greyhound profiles, form history, and open races from the GBGB portal via a structured JSON API.
What is the Org API?
This API exposes 9 endpoints covering greyhound racing data from the GBGB portal, including race results, meeting details, individual race data, and greyhound profiles. Use search_race_results to filter historical races by track, class, date, and race type, or get_greyhound_form to retrieve a dog's full race history with date-range filtering. Response fields cover trap positions, race classes, breeding lineage, trainer and owner names, and upcoming open race prize values.
curl -X GET 'https://api.parse.bot/scraper/04f3b8ab-38c4-4573-ad99-c54a8f337830/search_race_results?date=2026-07-08&page=1&limit=5&track=Romford&race_type=race&race_class=A1' \ -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 gbgb-org-uk-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.
"""GBGB Greyhound Racing API - Walkthrough: bounded, re-runnable; every call capped."""
from parse_apis.gbgb_greyhound_racing_api import GBGB, RaceType, GreyhoundNotFound
client = GBGB()
# Search recent race results filtered by race type.
for result in client.raceresults.search(race_type=RaceType.RACE, limit=3):
print(f"{result.raceDate} {result.trackName}: {result.dogName} won race {result.raceNumber}, class {result.raceClass}")
# Search for a greyhound by name, drill into its profile and form.
match = client.greyhoundsummaries.search(name="Romeo", limit=1).first()
if match:
profile = match.details()
print(f"Profile: {profile.dogName}, sire={profile.dogSire}, dam={profile.dogDam}, born={profile.dogBorn}")
for entry in profile.form(race_type=RaceType.RACE, limit=3):
print(f" {entry.raceDate} at {entry.trackName}: P{entry.resultPosition}, class {entry.raceClass}")
# Fetch a meeting by ID and inspect one of its races.
meeting = client.meeting(meetingId=448310)
race_detail = meeting.get_race(race_id="1223338")
print(f"Race at {race_detail.trackName} on {race_detail.meetingDate}: {race_detail.race.raceClass} over {race_detail.race.raceDistance}m")
# Handle a not-found greyhound gracefully.
try:
bad_profile = client.greyhound(dogId=999999999).form(limit=1).first()
except GreyhoundNotFound as exc:
print(f"Greyhound not found: {exc}")
print("Exercised: raceresults.search / greyhoundsummaries.search / details / form / meeting.get_race / GreyhoundNotFound")
Search and filter race results by track, class, date, and race type. Returns paginated results ordered by most recent. Each result item contains the winning greyhound's details and race metadata.
| Param | Type | Description |
|---|---|---|
| date | string | Race date in YYYY-MM-DD format. |
| page | integer | Page number for pagination. |
| limit | integer | Items per page. |
| track | string | Track name to filter by. Use get_tracks_list to see all available track names. |
| race_type | string | Race type filter. |
| race_class | string | Race class filter. Use get_race_classes_list to see all available classes. |
{
"type": "object",
"fields": {
"meta": "object with count (total results), page (current page), pageCount (total pages)",
"items": "array of race result objects containing dogName, trackName, raceDate, raceClass, meetingId, raceId, etc."
},
"sample": {
"data": {
"meta": {
"page": 1,
"count": 6431,
"pageCount": 1287
},
"items": [
{
"dogId": 656539,
"dogDam": "Illusion Dream",
"raceId": 1223056,
"dogName": "Run Away Terry",
"dogSire": "Dorotas Wildcat",
"raceDate": "10/06/2026",
"raceTime": "21:46:00",
"meetingId": 448270,
"ownerName": "Mr D P Brabon",
"raceClass": "A10",
"trackName": "Romford",
"raceNumber": "12",
"trapNumber": "4",
"trainerName": "D K Hurlock",
"raceDistance": 400,
"resultPosition": 1
}
]
},
"status": "success"
}
}About the Org API
Race Results and Meeting Data
The search_race_results endpoint returns paginated race result records filterable by track, race_class, date, and race_type. Each item in the items array carries fields like dogName, trackName, raceDate, raceClass, meetingId, and raceId. The meetingId and raceId values are the keys for drilling deeper: pass a meeting_id to get_meeting_details to get every race run at that meeting with full trap and result data, or pass both race_id and meeting_id to get_single_race to isolate a single race. Both endpoints return trackName and meetingDate alongside the structured race payload.
Greyhound Profiles and Form History
search_greyhound accepts a partial or full greyhound name and returns matching dogName and dogId pairs. Pass a dogId to get_greyhound_profile to retrieve breeding data — dogSire, dogDam, dogBorn, dogColour, dogSex — plus current trainerName and ownerName. get_greyhound_form uses the same dog_id and adds pagination (page, limit) and optional date_from/date_to filters, returning form entries with position, time, and track information across races and trials.
Reference Lists and Open Races
get_tracks_list and get_race_classes_list return the canonical sets of trackName and class values accepted as filters by search_race_results. This prevents trial-and-error when constructing filter queries. get_open_races returns upcoming open race listings with fields including RaceName, TrackName, RaceStageDate, and RaceStagePrize1st, paginated via page and limit. The total, last_page, and current_page fields in the response handle navigation across large listings.
The Org API is a managed, monitored endpoint for gbgb.org.uk — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when gbgb.org.uk 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 gbgb.org.uk 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 greyhound form guide by combining
get_greyhound_profilebreeding data withget_greyhound_formrace history entries. - Track class progression for a specific dog by filtering
get_greyhound_formresults byrace_classover a date range. - Aggregate track-level performance statistics using
search_race_resultsfiltered bytrackandrace_typeover a defined period. - Display full meeting cards on a racing dashboard by fetching all trap and result data via
get_meeting_details. - Surface upcoming open race prize values and dates from
get_open_racesfor a competition calendar or notification service. - Validate user-supplied filter inputs against canonical values from
get_tracks_listandget_race_classes_listbefore querying results. - Identify trainer or owner portfolios by aggregating
trainerNameandownerNamefields from multipleget_greyhound_profilelookups.
| 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 GBGB provide an official developer API?+
What does `get_greyhound_form` return, and how can I scope it to a date range?+
date_from and date_to parameters (both in YYYY-MM-DD format) and further filter by race_type to separate competitive races from trials. The meta object in the response gives you count, page, and pageCount for pagination.Is live or in-running race data available?+
Does the API return odds or betting market data?+
How do I get the right value to pass as a `track` or `race_class` filter in `search_race_results`?+
get_tracks_list returns the full array of valid trackName strings (e.g. 'Central Park', 'Hove'), and get_race_classes_list returns valid class values (e.g. 'A1', 'D3'). Use these endpoints to populate filter options and avoid rejected or zero-result queries caused by spelling mismatches.