Skip to main content
    Prices go up on January 1, 2027. Subscribe before then and keep today's price. How the price lock works
    Claimory API

    Your shop's claims, read by your own software

    The Claimory API is a read-only REST API that lets a collision repair shop on Elite pull its own claims into a reporting tool, a spreadsheet script or its own software: the claim number, status, carrier and adjuster, customer, vehicle, dates and dollar amounts, with a key each person makes for themselves.

    Base URL
    https://claimory.io/api/v1/
    Methods
    GET only
    Auth
    Authorization: Bearer clm_live_...
    Rate limit
    100 requests a minute per key
    Requests and answers

    Three routes, all of them GET

    The Claimory API has three routes: the claims list, one claim, and a check of the key itself. The answers below are the shapes the API returns, with sample values in place of a real shop's data.

    GET /claims lists the shop's claims, newest first. This call asks for two claims in the Repairing status and only the fields it needs; id and created_at always come back.

    curl "https://claimory.io/api/v1/claims?status=Repairing&limit=2&fields=claim_number,status,insurance_company,vehicle_year,vehicle_make,vehicle_model,due_date" -H "Authorization: Bearer $CLAIMORY_API_KEY"
    HTTP 200 X-RateLimit-Remaining: 98
    {
      "data": [
        {
          "id": "2a9d7c41-0e3b-4f8a-b6d2-91c5e7f3a018",
          "created_at": "2026-11-07T16:40:09.118+00:00",
          "claim_number": "CLM-1048",
          "status": "Repairing",
          "insurance_company": "Example Insurance",
          "vehicle_year": "2021",
          "vehicle_make": "Toyota",
          "vehicle_model": "Camry",
          "due_date": "2026-11-18"
        },
        {
          "id": "8c3f1e2d-7b4a-4c6e-9d1f-5a2b3c4d5e6f",
          "created_at": "2026-11-05T14:12:00.412+00:00",
          "claim_number": "CLM-1043",
          "status": "Repairing",
          "insurance_company": "Example Insurance",
          "vehicle_year": "2019",
          "vehicle_make": "Ford",
          "vehicle_model": "F-150",
          "due_date": "2026-11-14"
        }
      ],
      "has_more": true,
      "next_cursor": "WyIyMDI2LTExLTA1VDE0OjEyOjAwLjQxMiswMDowMCIsIjhjM2YxZTJkLTdiNGEtNGM2ZS05ZDFmLTVhMmIzYzRkNWU2ZiJd"
    }

    GET /claims/<id> reads a single claim. A claim from another shop gets the same 404 as one that does not exist, so a key cannot probe for other shops' claims.

    curl "https://claimory.io/api/v1/claims/8c3f1e2d-7b4a-4c6e-9d1f-5a2b3c4d5e6f?fields=claim_number,carrier_claim_number,deductible,quoted_amount,delivered_at" -H "Authorization: Bearer $CLAIMORY_API_KEY"
    HTTP 200 X-RateLimit-Remaining: 97
    {
      "data": {
        "id": "8c3f1e2d-7b4a-4c6e-9d1f-5a2b3c4d5e6f",
        "created_at": "2026-11-05T14:12:00.412+00:00",
        "claim_number": "CLM-1043",
        "carrier_claim_number": "EX-55210-87",
        "deductible": 500,
        "quoted_amount": 4862.35,
        "delivered_at": null
      }
    }

    GET /me returns the key, the shop it belongs to and the shop's plan, a quick way to test a new key before building on it.

    curl https://claimory.io/api/v1/me -H "Authorization: Bearer $CLAIMORY_API_KEY"
    HTTP 200 X-RateLimit-Remaining: 99
    {
      "data": {
        "key": {
          "id": "0b7e4f2a-5c1d-4e8b-9a3f-2d6c8e1f4a90",
          "name": "Reporting integration",
          "prefix": "clm_live_3f9a61c2",
          "created_at": "2026-11-02T15:04:11.530+00:00",
          "last_used_at": "2026-11-11T13:20:45.207+00:00"
        },
        "workspace": {
          "id": "5d2e8b17-3c9f-4a61-8e4d-7f0b2c6a9e13",
          "name": "Sample Collision Center"
        },
        "plan": "elite"
      }
    }

    The plan is checked on every request, not when the key was made, so a shop that moves off Elite gets this answer from then on, unless it kept the API from Professional.

    curl https://claimory.io/api/v1/claims -H "Authorization: Bearer $CLAIMORY_API_KEY"
    HTTP 403
    {
      "error": "The Claimory API requires the Elite plan or higher.",
      "code": "plan.elite_required"
    }
    Claim fields

    What a key can read, and what stays inside

    The Claimory API returns only the claim fields on this list, and a key reads only its own shop's claims. Internal notes, flags, the customer portal PIN, AI review results and who a claim is assigned to never leave through the API, and there are no webhooks and no write access.

    • id
    • claim_number
    • status
    • priority
    • archived
    • insurance_company
    • carrier_claim_number
    • carrier_policy_number
    • carrier_adjuster_name
    • carrier_adjuster_email
    • carrier_adjuster_phone
    • customer_first_name
    • customer_last_name
    • customer_email
    • customer_phone
    • vehicle_year
    • vehicle_make
    • vehicle_model
    • vehicle_color
    • vin
    • license_plate
    • mileage
    • is_drivable
    • is_drp
    • date_of_loss
    • start_date
    • due_date
    • target_completion_date
    • delivered_at
    • deductible
    • quoted_amount
    • parts_cost
    • labor_cost
    • other_cost
    • created_at
    • updated_at
    API keys

    A key for each person, shown once

    Each person in a Claimory shop on Elite makes their own API keys, up to 5 active at a time, and a key stops working the moment its owner leaves the shop.

    The API Keys row in the Security section of the Claimory Account page: read-only access to your data through the Claimory API, a Create API key button, and a note that a key connects reporting tools or the shop's own scripts.
    API Keys sits in the Security section of the Account page.
    1. 01

      Open the Account page in Claimory and find API Keys.

    2. 02

      Create an API key and give it a name, such as Reporting integration.

    3. 03

      Copy the key on the spot. Claimory shows it once and keeps only a hash.

    4. 04

      Revoke a key any time, and anything using it stops at once.

    What shops build

    Your claims, in the tools you already use

    The Claimory API is for a collision repair shop that wants its claim data somewhere else as well: a spreadsheet, a database, a reporting tool or a script someone at the shop wrote.

    1. 01

      A nightly copy in a spreadsheet or BI tool

      A script asks the Claimory API for claims with updated_since set to its last run, pages through them with next_cursor, and writes the rows to a spreadsheet, a database or a reporting tool. Only the claims that changed come back each night.

    2. 02

      A carrier mix report

      The carrier, the carrier claim number and the status come back on every claim, so a shop can count its open and closed claims by insurance carrier outside Claimory, for a DRP review or the owner's month-end numbers.

    3. 03

      Dates for the shop's own cycle math

      The loss, start, due and delivery dates on each claim let a shop work out keys-in to keys-out days in its own tool, next to the Cycle Time tab Claimory already has.

    4. 04

      Money fields for the books

      The deductible, the quoted amount and the parts, labor and other costs come back as numbers on each claim, ready for a bookkeeper's sheet without retyping a repair order.

    On every request

    Five checks before a claim leaves

    The Claimory API checks every request on its own, with no session to remember, so a revoked key, a lapsed plan or a wrong shop is caught the moment it happens.

    • The key is looked up by its hash. Claimory never stores the key itself.
    • The key's own limit of 100 requests a minute, and 300 a minute from one IP address, are checked.
    • The shop's plan is checked on every request, not once when the key was made, so a shop that leaves Elite gets 403 plan.elite_required unless it kept the API from Professional.
    • The key reads only its own shop. A claim id from another shop gets the same 404 as a claim that does not exist.
    • Only the 36 listed claim fields can come back. Internal notes, flags, the portal PIN and AI review results are not on the list.
    Good to know

    What the API does not do

    • No write access: any method other than GET gets a 405.
    • No webhooks: a script polls with updated_since.
    • No Zapier or Make connector.
    • Claims only, through /claims and /claims/<id>, plus /me to check a key.
    • Elite only for new shops (a Professional shop paying on November 10, 2026 keeps it), with up to 5 active keys per person in a shop.
    Works with

    Related Claimory pages

    Put your claims where your reports live

    The Claimory API is included with Elite. Try Claimory free for 14 days, no credit card.

    Questions

    What developers ask about the API

    Yes. Claimory has a read-only REST API at https://claimory.io/api/v1/ for collision repair shops on Elite. A key can list the shop's claims, read a single claim and check which shop and plan it belongs to. The API answers GET requests only, so it can feed a reporting tool, a spreadsheet script or a shop's own software, but nothing can create or change a claim through it.

    The Claimory API returns 36 claim fields: the claim number, status and priority, the carrier, carrier claim number, policy number and adjuster contact, the customer's name, email and phone, the vehicle, VIN, plate and mileage, the loss, start, due and delivery dates, and the deductible, quoted amount and parts, labor and other costs. Internal notes, flags, the customer portal PIN, AI review results and who the claim is assigned to never leave through the API.

    The Claimory API is included with Elite. New Starter and Professional shops do not get it, and neither does the free trial; a shop already paying for Professional on November 10, 2026 keeps the API it had. Claimory checks the shop's plan on every request rather than when a key was made, so a shop that moves off Elite gets a 403 answer with the code plan.elite_required from then on, unless it kept the API from Professional. On Elite, every person in the shop can make their own keys.

    Each person in a Claimory shop on Elite creates their own keys in the API Keys section of the Account page, names each one and copies it once, because Claimory shows a key only when it is made and stores only a hash of it. A person can hold up to 5 active keys in a shop. Revoking a key stops anything using it at once, and a key stops working if its owner leaves the shop.

    The Claimory API allows 100 requests a minute for each key, plus a wider limit of 300 a minute from one IP address. Every successful answer carries X-RateLimit-Remaining and X-RateLimit-Reset headers so a script can slow itself down. A request over the limit gets a 429 answer with a Retry-After header giving the seconds to wait before trying again.

    The Claimory API lists claims newest first, 25 at a time unless the request asks for up to 100 with the limit parameter. Each page says whether more claims follow and gives a next_cursor to send back for the next page, which keeps pages stable while the shop adds claims. The status, archived and updated_since parameters narrow the list, and fields picks which claim fields come back.

    No. The Claimory API is read-only: any request other than GET gets a 405 answer, so no key can create, change or delete a claim. Claimory has no webhooks today, so a script polls the claims list with updated_since to find what changed since its last run. Claimory also has no Zapier or Make connector; a shop that wants claims in another tool calls the API from its own script.

    A script sends its Claimory API key in an Authorization header on every request, as Bearer followed by the key. Every Claimory key starts with clm_live_ and is made in the API Keys section of the Account page. A quick first call is GET /me, which returns the key's name and prefix, when it was made and last used, the shop it belongs to and the shop's plan, so a new key can be tested before anything is built on it.

    No. Every Claimory API key belongs to one shop, and every request reads only that shop's claims. Asking for a claim id from another shop gets the same 404 answer as asking for a claim that does not exist, so a key cannot even learn that another shop's claim is there. A person who works in two Claimory shops makes a separate key in each one.

    With the Claimory API a shop can keep a nightly copy of its claims in a spreadsheet, a database or a reporting tool, using updated_since to fetch only what changed. The carrier, status, dates and dollar fields on each claim support a carrier mix report, the shop's own cycle time math, or a bookkeeper's sheet. Because the API is read-only, none of those tools can change a claim in Claimory.

    The Claimory API answers a missing claim with a 404 and a JSON error code, and it gives the same 404 for a claim that belongs to another shop. Other refusals carry an error code the same way: 401 for a missing or wrong key, 403 with plan.elite_required when the shop has no API access on its plan, and 405 for any method other than GET. A key over its rate limit gets a 429 with a Retry-After header and a plain error message.