DomainCatcher API: search, order and automate domains

Author: Leo Kobes Published: 22 July 2026 Updated: 3 August 2026 Product information last verified: 3 August 2026

New · REST API · Automation

The new DomainCatcher API lets you retrieve and create backorders, search RGP and ReCatch domains, take over ReCatch domains, register free .de domains, and buy domains from the Domex. The interface is aimed at domain investors, publishers, SEO teams and developers who want to automate recurring domain processes.

The API is provided technically and contractually by DomainCatcher.com. deinrecatch.de explains the available endpoints, prerequisites, responses and security rules. API key, balance, purchases and domain management remain entirely within the DomainCatcher account.

Create an API key at DomainCatcher View endpoints About DomainCatcher

After logging in: Account → API. External link to DomainCatcher.com – the current prices and terms apply there.

The API at a glance

Who is the API for?

The API does not provide full domain management or DNS management – it specifically covers backorder, RGP, ReCatch, Free and Domex processes.

Prerequisites for API access

• An active DomainCatcher account.
• A tier level that allows API access.
• API key from: Account → API
• Sufficient DC prepaid balance for paid actions.
• Endpoint-specific authorisation.
• For Domex purchases, a fully verified standard contact.
• Secure server-side storage of the API key.

Authentication with an API key

Preferred header:

apiKey: DEIN_API_KEY

Other forms accepted according to the documentation:

X-Api-Key: DEIN_API_KEY
Authorization: Bearer DEIN_API_KEY

Also technically accepted: auth_key in the body or query.

• Never store the API key in the frontend.
• Never publish the API key in client-side browser JavaScript.
• Never commit the API key to Git.
• Never show the API key in screenshots.
• Never transmit the API key via Google Analytics.
• Never use the API key as a URL parameter in publicly visible examples.
• Do not use production keys in demo code.
• Manage the key server-side as an environment variable.
• Rotate the key in your DomainCatcher account immediately if disclosure is suspected.

Unified JSON format

All responses generally follow this pattern:

{
  "success": true,
  "msg": "…",
  "data": {}
}

• success shows the general success.
• msg contains a human-readable message.
• data depends on the endpoint.
• On errors, data.error can contain a specific error code.
• An HTTP 201 response can start an asynchronous follow-up process.

HTTP status codes

No further status codes are documented for these endpoints.

Why data.restricted must be checked

The following list endpoints may only deliver a teaser or first page if the tier is restricted or the balance is insufficient: RGP, ReCatch, Free, Domex.

{
  "restricted": true,
  "total": 245,
  "count": 10,
  "domains": []
}

A successful HTTP response does not automatically mean the full list was delivered. Applications must evaluate data.restricted and must not present a teaser list as the complete inventory.

All currently documented endpoints

GET /api3/backorder

Purpose: Retrieve backorders of the authenticated user.

At least one parameter required: domain, status

Allowed status values: pending, pending extended, successful, unsuccessful, user storno

curl -X GET \
  "https://api.domaincatcher.com/api3/backorder" \
  -H "apiKey: DEIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"status":"pending"}'

Response data:

[
  {
    "domain": "dein-recatch.de",
    "order_date": "DATUM",
    "status": "pending",
    "drop_date": "DATUM"
  }
]

The example data is a placeholder; no real customer or order data is shown.

POST /api3/backorder

Purpose: Create a new backorder.

Required parameter: domain

• .de only
• domain must be in RGP
• sufficient balance
• tier must allow backorders
• parallel backorder limit must not be exceeded

curl -X POST \
  "https://api.domaincatcher.com/api3/backorder" \
  -H "apiKey: DEIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domain":"dein-recatch.de"}'

Possible results: 201 Created on success, 400 Bad Request for domain, RGP, balance or limit issues, 403 Forbidden for missing tier authorisation.

GET /api3/rgp

Purpose: Retrieve RGP domains for a period or via free-text search.

Required parameter: date

Allowed values: drop_in_30_days, drop_in_29_days, drop_in_2_days, drop_in_1_day, search

For search: at least three characters, allowed characters per documentation, German umlauts and ß possible.

curl -X GET \
  "https://api.domaincatcher.com/api3/rgp" \
  -H "apiKey: DEIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"date":"drop_in_1_day"}'

Response structure:

{
  "date": "drop_in_1_day",
  "restricted": false,
  "domains": [
    {
      "domain": "dein-recatch.de",
      "tld": "de",
      "drop_at": "DATUM",
      "did": "WERT",
      "blv": "WERT",
      "age": "WERT",
      "tlc": "WERT"
    }
  ]
}

The scoring fields (did, blv, age, tlc) are not freely interpreted here, since their exact scale is not specified in the provided documentation.

GET /api3/recatch

Purpose: Retrieve the current ReCatch list.

Parameters (all optional): search, limit, offset

Default limit: 100 · Maximum limit: 500. The list is shortened with restricted access.

curl -X GET \
  "https://api.domaincatcher.com/api3/recatch" \
  -H "apiKey: DEIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"search":"recatch","limit":100,"offset":0}'

Response structure:

{
  "restricted": false,
  "total": 1,
  "offset": 0,
  "limit": 100,
  "count": 1,
  "domains": [
    {
      "domain": "dein-recatch.de",
      "tld": "de",
      "drop_at": "DATUM",
      "did": "WERT",
      "blv": "WERT",
      "age": "WERT",
      "tlc": "WERT",
      "recatchId": "WERT"
    }
  ]
}

total is the total count, count the number of returned entries, offset and limit are used for pagination, restricted indicates a limited view.

POST /api3/recatch

Purpose: Take over a ReCatch domain.

Required parameter: domain

Prerequisites: .de domain, domain must be in the correct ReCatch/RGP status, sufficient prepaid balance, appropriate tier authorisation, API access.

curl -X POST \
  "https://api.domaincatcher.com/api3/recatch" \
  -H "apiKey: DEIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domain":"dein-recatch.de"}'

Response:

{
  "success": true,
  "msg": "Meldung",
  "data": {
    "pending": true
  }
}

pending: true means that the reservation or technical processing is still ongoing. Final success must not be displayed prematurely.

GET /api3/free

Purpose: Retrieve domains that have already been deleted and can generally be newly registered.

Optional parameters: search, date, limit, offset

Date values: dropToday, drop-1

Wildcard search per documentation: a leading * searches for suffixes, a trailing * searches for prefixes, an asterisk in the middle of the search term is rejected.

curl -X GET \
  "https://api.domaincatcher.com/api3/free" \
  -H "apiKey: DEIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"date":"dropToday","limit":100,"offset":0}'

Response fields: date, restricted, total, offset, limit, count, domains, freeId

A domain in the Free list is not a permanent availability guarantee. Availability is checked again before actual registration.

POST /api3/free

Purpose: Newly register a domain from the Free list.

Required parameter: domain

Prerequisites: .de only, domain must still be on the Free list, domain must still be available at the registry, sufficient balance, suitable and verified contact where required for the process.

curl -X POST \
  "https://api.domaincatcher.com/api3/free" \
  -H "apiKey: DEIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domain":"DOMAIN-AUS-DER-FREE-LISTE.de"}'

Success data:

{
  "domain": "DOMAIN-AUS-DER-FREE-LISTE.de",
  "taskmanager_id": 123,
  "domain_id": 456,
  "netto": "BETRAG",
  "msg": "Meldung"
}

Registration is processed asynchronously via the task manager. 201 Created means the process was created; the final domain status must be checked afterwards. No domain is presented here as actually free.

GET /api3/domex

Purpose: Retrieve current Domex offers.

Optional parameters: search, tld, provider, minPrice, maxPrice, limit, offset

Provider values: all, domex, user

Pricing logic: price is the price valid for the user, is_netto shows whether this price is shown net, price_netto is always the net price. No blanket net or gross price assumption is made.

curl -X GET \
  "https://api.domaincatcher.com/api3/domex" \
  -H "apiKey: DEIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"search":"burger","provider":"domex","limit":100,"offset":0}'

Relevant response fields: domain, tld, type, price, price_netto, is_netto, provider, did, blv, age, tlc, domainId, is_own_domain

domainId is the unique and preferred ID for the subsequent Domex purchase.

POST /api3/domex

Purpose: Buy a domain from the Domex.

Required parameter: one of either domain or domain_id (domain_id preferred).

curl -X POST \
  "https://api.domaincatcher.com/api3/domex" \
  -H "apiKey: DEIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domain_id":12345}'

Prerequisites: the domain must still be actively offered, the domain must not belong to the buyer, sufficient balance, fully verified standard contact, the domain must not already be sold or in processing.

Documented error codes: not_found, own_domain, no_money, not_available, selling, billing_failed, nis2

nis2 is returned with 403 Forbidden; other documented errors may appear in data.error. No custom error codes are added here.

Technical particularity of GET requests

The provided documentation shows several GET requests with a JSON body. Some HTTP clients, browser libraries, proxies or caches handle GET requests with a body differently. Use the request form documented by DomainCatcher and test the server-side HTTP library you choose. No alternative parameter transmission is invented here that is not officially documented.

For this reason, this page deliberately avoids browser fetch() examples with a GET body, since this is not permitted or reliable depending on the implementation. Preferred examples are cURL and server-side PHP cURL.

What can be automated with the API?

Further reading: Evaluating a domain · Checking backlinks · Checking domain history · Trademark check · ReCatch checklist

Error handling for integrations

• Check the HTTP status code.
• Check success.
• Log msg.
• Check data.error.
• Check restricted for lists.
• For asynchronous processes, store pending or the IDs.
• Do not blindly repeat a purchase request.
• Use backoff on network errors.
• Do not write the API key to logs on 401.
• Do not automatically retry endlessly on 400.
• Check tier or contact status on 403.
• Do not risk multiple purchases through aggressive retries on 500.

A specific retry frequency is not stated here as an official API requirement as long as no rate limit is documented.

Securing the API key and purchase actions

• Use the API key server-side only.
• Store secrets as environment variables.
• Separate production and test systems.
• Clean authentication headers from logs.
• Do not automate purchase actions without a plausibility check.
• Normalise the domain name before POST calls.
• Only allow .de where the endpoint requires it.
• Re-check price and domain directly before purchase.
• Do not assume idempotency unless it is documented.
• Do not blindly retry failed requests.
• Monitor balance and tier authorisation.
• Prefer domain_id for Domex purchases.
• Rotate the API key immediately if disclosure is suspected.
• Never write an API response unfiltered into public HTML.

Frequently asked questions about the DomainCatcher API

Further reading

About DomainCatcher · What is ReCatch? · Backorder · RGP & free domains · Domex · Economic relationship · Editorial guidelines · Privacy