Limits

This page collects every limit you can run into when you call the Vetnio API: how many requests a key may make, how long a request may run, how large bodies, files and texts may be, how many objects you can create, and how long signed links last. Design your integration around them from the start; most of them fail loudly, but a few currently fail with a generic 500.

Rate limits

Organization keys (sk_org_…) and clinic keys (sk_ws_…) are rate limited per key:

Every request the key is allowed to make counts, including requests that then fail validation and requests that are themselves rejected with 429. Retrying in a tight loop while you are limited therefore uses up the daily quota. GET/api-key shows the limits and how many requests the key has made today and over the last 30 days.

Personal keys (sk_live_…) have no per-key rate limit today. Treat that as headroom, not as permission: keep your request rate reasonable, run long jobs sequentially, and handle 429 anyway so your integration keeps working if limits are introduced.

When you hit a limit

The response is 429 Too Many Requests. The message tells you how long to wait; there is no Retry-After header.

{
  "message": "Rate limit of 60 requests per minute reached. Retry in 53 seconds.",
  "code": "TOO_MANY_REQUESTS",
  "data": {
    "code": "TOO_MANY_REQUESTS",
    "httpStatus": 429,
    "path": "apiKeys.me",
    "zodError": null
  }
}

The other two limits say when they reset:

Daily limit of 10000 requests reached. It resets at 2026-10-05T00:00:00.000Z.

Daily limit of 20 requests with note-quality columns (avgReadingSeconds, avgEditingSeconds, acceptanceRate, draftOutcome) reached. Leave those columns out, or retry after 2026-10-05T00:00:00.000Z.

Wait until the next full minute, or until the stated time, before you send the next request. A request without note-quality columns still works when only the note-quality limit is reached. A simple approach in code:

import re, time
from datetime import datetime, timezone

def wait_after_429(message: str) -> None:
    seconds = re.search(r"Retry in (\d+) seconds", message)
    if seconds:
        time.sleep(int(seconds.group(1)) + 1)
        return
    reset = re.search(r"(\d{4}-\d{2}-\d{2}T[\d:.]+Z)", message)
    if reset:
        resets_at = datetime.fromisoformat(reset.group(1).replace("Z", "+00:00"))
        raise RuntimeError(f"Daily limit reached; resume after {resets_at.isoformat()}")

Request timeout

A request may run for up to 10 minutes. Most requests finish in well under a second; the ones that can take long are those that wait for AI work, such as generating a clinical note or asking VetsGPT.

If a request runs past 10 minutes, the hosting platform ends it with 504 Gateway Timeout, in the platform's own format rather than Vetnio's JSON error object. The work may still have finished on Vetnio's side. Before you retry a request that creates or generates something, check its result first; see Retrying safely. Set your HTTP client's timeout a little above 10 minutes for these endpoints so you do not give up before Vetnio does.

Request body and file sizes

On v2, every POST, PUT and PATCH must send Content-Type: application/json and a JSON body, {} if there is nothing to send. Otherwise the request fails with 415; see Versioning.

Text lengths

Object counts

Where a limit currently surfaces as 500 with An unexpected error occurred, check your input against this table before you retry. The same request will keep failing.

Usage export

Page sizes for the other list endpoints are in Pagination.

Link lifetimes

Several endpoints return signed storage URLs. They work without your API key, so treat them as secrets, and they stop working after a fixed time:

When a link has expired, request a new one from the same endpoint; the stored content is not affected. For an uploaded file whose upload URL expired before you used it, delete the file and start the upload again.

The old key's grace period after Replace key on an organization or clinic key is 24 hours; see Authentication.

Next steps

• Errors: the error format and retry rules.
• Pagination: page sizes and how to page through lists.
• Export usage statistics: working within the usage export limits.