Org APIthekennelclub.org.uk ↗
Access 220+ pedigree breeds, official breed standards, characteristics, and registration forms from The Kennel Club UK via 5 structured endpoints.
What is the Org API?
The Kennel Club UK API covers 220+ recognised pedigree breeds across 5 endpoints, returning structured data on breed characteristics, group classifications, and official breed standard documents. The get_breeds_list endpoint delivers the full catalogue with slugs and group assignments needed to drive all other lookups, while get_breed_standard returns section-by-section text from each breed's official KC standard document.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/65dd97b9-fc6a-4022-8e85-b87b5e48619f/get_breeds_list' \ -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 thekennelclub-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.
"""Royal Kennel Club SDK — breed research workflow."""
from parse_apis.royal_kennel_club_api import KennelClub, BreedGroup, BreedNotFound
client = KennelClub()
# Search for gundog breeds using the BreedGroup enum
for breed in client.breedsummaries.search(group=BreedGroup.GUNDOG, limit=3):
print(breed.name, breed.slug)
# Drill into one breed's full detail via .first()
lab = client.breedsummaries.search(query="labrador", limit=1).first()
if lab:
detail = lab.details()
print(detail.name, detail.characteristics)
# Navigate to the breed standard from the same summary
standard = lab.standard()
print(standard.breed, list(standard.sections.keys())[:4])
# Handle a breed that doesn't exist
try:
bad = client.breedsummaries.search(query="nonexistent-xyz", limit=1).first()
if bad:
bad.details()
except BreedNotFound as exc:
print(f"Not found: breed_slug={exc.breed_slug}, group_slug={exc.group_slug}")
# List registration forms
for form in client.registrationforms.list(limit=5):
print(form.title, form.price)
print("exercised: breedsummaries.search / details / standard / registrationforms.list")
Retrieve the full list of pedigree breeds recognised by the Royal Kennel Club. Returns all 220+ breeds with their group classification and URL slugs. No filtering — use search_breeds for filtered results.
No input parameters required.
{
"type": "object",
"fields": {
"total": "integer count of breeds returned",
"breeds": "array of breed summary objects with name, group, group_slug, slug, and url"
},
"sample": {
"data": {
"total": 225,
"breeds": [
{
"url": "https://www.royalkennelclub.com/search/breeds-a-to-z/breeds/toy/affenpinscher/",
"name": "Affenpinscher",
"slug": "affenpinscher",
"group": "Toy",
"group_slug": "toy"
}
]
},
"status": "success"
}
}About the Org API
Breed Catalogue and Detail
get_breeds_list returns every pedigree breed recognised by The Kennel Club UK — currently 220+ — as an array of objects each containing name, group, group_slug, slug, and url. These slugs are required inputs for the detail and standard endpoints. get_breed_detail accepts a breed_slug and group_slug and returns a characteristics object (keyed fields including Size, Exercise, Grooming, and Lifespan), an about description string, and the canonical page URL. Note that about may be empty for some breeds.
Breed Standards
get_breed_standard returns the full official KC breed standard for any recognised breed, structured as a sections object keyed by heading — covering General appearance, Temperament, Colour, and physical detail sections such as Head, Body, and Feet. This is the same document judges use at KC-licensed shows. Both breed_slug and group_slug are required; both are available from get_breeds_list or search_breeds.
Search, Filter, and Registration
search_breeds accepts a query string for name matching and a group parameter for group filtering, both case-insensitive substring matches. Omitting both parameters returns all breeds. Results share the same shape as get_breeds_list output: name, group, group_slug, slug, and url. get_registration_forms is a no-input endpoint that returns the current list of KC registration form types — including standard registrations, transfers, and downloadable forms — with title and price per item.
The Org API is a managed, monitored endpoint for thekennelclub.org.uk — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when thekennelclub.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 thekennelclub.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 breed selector tool that filters by group using
search_breedswith thegroupparameter. - Display KC-standard characteristics (exercise needs, grooming, lifespan) for a breed detail page using
get_breed_detail. - Populate a breed comparison table by calling
get_breed_detailfor multiple slugs fromget_breeds_list. - Render official KC breed standard text section-by-section for judges, trainers, or breeders using
get_breed_standard. - Track current KC registration form pricing by polling
get_registration_formsfor changes to thepricefield. - Feed a dog breed quiz or recommendation engine with the full 220+ breed list and group classifications.
- Generate a static breed encyclopedia by iterating
get_breeds_listslugs and fetchingget_breed_detailfor each.
| 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 Kennel Club UK have an official developer API?+
What does `get_breed_standard` actually return — is it the full document?+
get_breed_standard returns the official KC breed standard structured as a sections object, where each key is a section heading (e.g. General appearance, Temperament, Colour, Size) and each value is the corresponding text. Coverage matches what The Kennel Club publishes for that breed; section headings vary by breed. The raw document title or publication date are not included in the response.Can I look up health test results or Assured Breeder listings through this API?+
Are there any breeds for which `get_breed_detail` returns incomplete data?+
about field is documented as potentially empty for some breeds, meaning not every breed has descriptive text. The characteristics object fields depend on what The Kennel Club publishes per breed, so key presence (e.g. a specific size or grooming rating) is not guaranteed to be uniform across all 220+ breeds.Does `search_breeds` support filtering by multiple groups or exact name matches?+
query and group parameters use case-insensitive substring matching. Multiple simultaneous group filters are not supported — group accepts a single string. For multi-group filtering you would need to call search_breeds once per group and merge results client-side, or use get_breeds_list and filter locally. You can fork this API on Parse and revise the search logic to support additional filter combinations.