You can access the Domain DNS & WHOIS (RDAP) Lookup: registrar, expiry, SPF/DMA programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.1",
    "x-build-id": "TmHtvcnRZkGdFj5Fa"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/glistening_film~domain-dns-rdap-lookup/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-glistening_film-domain-dns-rdap-lookup",
        "x-openai-isConsequential": false,
        "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
        "tags": [
          "Run Actor"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/inputSchema"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "token",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "Enter your Apify token here"
          }
        ],
        "responses": {
          "200": {
            "description": "OK"
          }
        }
      }
    },
    "/acts/glistening_film~domain-dns-rdap-lookup/runs": {
      "post": {
        "operationId": "runs-sync-glistening_film-domain-dns-rdap-lookup",
        "x-openai-isConsequential": false,
        "summary": "Executes an Actor and returns information about the initiated run in response.",
        "tags": [
          "Run Actor"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/inputSchema"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "token",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "Enter your Apify token here"
          }
        ],
        "responses": {
          "200": {
            "description": "OK",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/runsResponseSchema"
                }
              }
            }
          }
        }
      }
    },
    "/acts/glistening_film~domain-dns-rdap-lookup/run-sync": {
      "post": {
        "operationId": "run-sync-glistening_film-domain-dns-rdap-lookup",
        "x-openai-isConsequential": false,
        "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
        "tags": [
          "Run Actor"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/inputSchema"
              }
            }
          }
        },
        "parameters": [
          {
            "name": "token",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "Enter your Apify token here"
          }
        ],
        "responses": {
          "200": {
            "description": "OK"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "inputSchema": {
        "type": "object",
        "required": [
          "domains"
        ],
        "properties": {
          "domains": {
            "title": "Domains",
            "maxItems": 1000,
            "type": "array",
            "description": "Up to 1000 domains or URLs per run (duplicates are checked once). URLs are reduced to their host (scheme, path, port and a leading www. are stripped). Invalid entries are reported as invalid_input and never charged.",
            "items": {
              "type": "string"
            }
          },
          "recordTypes": {
            "title": "DNS record types",
            "type": "array",
            "description": "DNS record types to look up for each domain.",
            "items": {
              "type": "string",
              "enum": [
                "A",
                "AAAA",
                "MX",
                "NS",
                "TXT",
                "CNAME",
                "SOA",
                "CAA"
              ],
              "enumTitles": [
                "A (IPv4 address)",
                "AAAA (IPv6 address)",
                "MX (mail servers)",
                "NS (nameservers)",
                "TXT (text)",
                "CNAME (alias)",
                "SOA (zone info)",
                "CAA (certificate authority)"
              ]
            },
            "default": [
              "A",
              "AAAA",
              "MX",
              "NS",
              "TXT"
            ]
          },
          "includeRdap": {
            "title": "Include RDAP registration data",
            "type": "boolean",
            "description": "Fetch registrar, registration / expiration / last-changed dates, status and nameservers via the official IANA RDAP directory (the modern, protocol-based successor of WHOIS).",
            "default": true
          },
          "includeEmailSecurity": {
            "title": "Include email security check",
            "type": "boolean",
            "description": "Check SPF (TXT record starting v=spf1), DMARC (TXT at _dmarc.<domain>, p= policy) and whether the domain has MX records.",
            "default": true
          }
        }
      },
      "runsResponseSchema": {
        "type": "object",
        "properties": {
          "data": {
            "type": "object",
            "properties": {
              "id": {
                "type": "string"
              },
              "actId": {
                "type": "string"
              },
              "userId": {
                "type": "string"
              },
              "startedAt": {
                "type": "string",
                "format": "date-time",
                "example": "2025-01-08T00:00:00.000Z"
              },
              "finishedAt": {
                "type": "string",
                "format": "date-time",
                "example": "2025-01-08T00:00:00.000Z"
              },
              "status": {
                "type": "string",
                "example": "READY"
              },
              "meta": {
                "type": "object",
                "properties": {
                  "origin": {
                    "type": "string",
                    "example": "API"
                  },
                  "userAgent": {
                    "type": "string"
                  }
                }
              },
              "stats": {
                "type": "object",
                "properties": {
                  "inputBodyLen": {
                    "type": "integer",
                    "example": 2000
                  },
                  "rebootCount": {
                    "type": "integer",
                    "example": 0
                  },
                  "restartCount": {
                    "type": "integer",
                    "example": 0
                  },
                  "resurrectCount": {
                    "type": "integer",
                    "example": 0
                  },
                  "computeUnits": {
                    "type": "integer",
                    "example": 0
                  }
                }
              },
              "options": {
                "type": "object",
                "properties": {
                  "build": {
                    "type": "string",
                    "example": "latest"
                  },
                  "timeoutSecs": {
                    "type": "integer",
                    "example": 300
                  },
                  "memoryMbytes": {
                    "type": "integer",
                    "example": 1024
                  },
                  "diskMbytes": {
                    "type": "integer",
                    "example": 2048
                  }
                }
              },
              "buildId": {
                "type": "string"
              },
              "defaultKeyValueStoreId": {
                "type": "string"
              },
              "defaultDatasetId": {
                "type": "string"
              },
              "defaultRequestQueueId": {
                "type": "string"
              },
              "buildNumber": {
                "type": "string",
                "example": "1.0.0"
              },
              "containerUrl": {
                "type": "string"
              },
              "usage": {
                "type": "object",
                "properties": {
                  "ACTOR_COMPUTE_UNITS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_WRITES": {
                    "type": "integer",
                    "example": 1
                  },
                  "KEY_VALUE_STORE_LISTS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_INTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_EXTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_SERPS": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              },
              "usageTotalUsd": {
                "type": "number",
                "example": 0.00005
              },
              "usageUsd": {
                "type": "object",
                "properties": {
                  "ACTOR_COMPUTE_UNITS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATASET_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "KEY_VALUE_STORE_WRITES": {
                    "type": "number",
                    "example": 0.00005
                  },
                  "KEY_VALUE_STORE_LISTS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_READS": {
                    "type": "integer",
                    "example": 0
                  },
                  "REQUEST_QUEUE_WRITES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_INTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "DATA_TRANSFER_EXTERNAL_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_SERPS": {
                    "type": "integer",
                    "example": 0
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Domain DNS & WHOIS (RDAP) Lookup: registrar, expiry, SPF/DMA OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Domain DNS & WHOIS (RDAP) Lookup: registrar, expiry, SPF/DMA from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Domain DNS & WHOIS (RDAP) Lookup: registrar, expiry, SPF/DMA API in Python

Domain DNS & WHOIS (RDAP) Lookup: registrar, expiry, SPF/DMA API in JavaScript

Domain DNS & WHOIS (RDAP) Lookup: registrar, expiry, SPF/DMA API through CLI

Domain DNS & WHOIS (RDAP) Lookup: registrar, expiry, SPF/DMA API

Bulk domain WHOIS, DNS, SSL, and tech stack in one call

shipsatnight/domain-intelligence-suite

Point it at a list of domains. Get registrar/age, DNS, a real TLS handshake, and detectable tech — pay only for modules that return. No browser, no proxy bill.

Donovan

Bulk Domain Intel: WHOIS/RDAP, DNS, Email Security & SSL

bigdavidson/domain-intel-bulk

Bulk domain lookup: registrar and expiry (RDAP), A/AAAA/MX/NS/TXT/CAA records, SPF/DMARC/MTA-STS/BIMI email-security grade, mail provider, SSL certificate expiry, optional tech-stack detection.

Jack Sheward

Domain WHOIS & DNS Checker — Bulk Lookup

hichemdev/domain-whois-scraper

Bulk WHOIS/RDAP and DNS lookup: registrar, creation and expiry dates, days until expiry, status, nameservers, DNSSEC, A/AAAA/MX/TXT records, SPF and DMARC. No API key.

Hichem Ben Moussa

Domain WHOIS & DNS Lookup — RDAP, DNS Records, SPF/DMARC, Bulk

chorelet/domain-whois-dns-scraper

Bulk domain intelligence: WHOIS via RDAP (registrar, dates, status, nameservers, availability), DNS records (A, AAAA, MX, NS, TXT, CNAME, SOA), email provider, SPF/DMARC and an optional website check. Domains, URLs or emails in, CSV/JSON out.

Chorelet

Domain, DNS & WHOIS Intelligence

tindacloud/domain-dns-intelligence

Bulk domain age checker and WHOIS lookup: registrar, creation and expiry dates, DNS records, SPF and DMARC, SSL certificate and website response. Official RDAP data, no blocking.

Seungki Min

Domain WHOIS Lookup (RDAP) – Expiry, Registrar, DNS & SSL

rowfeed/domain-rdap-checker

Official RDAP domain lookups: registrar, expiry, statuses, nameservers, DNSSEC, plus optional DNS (A/MX/NS/TXT) and TLS cert expiry. Registrar entity only - never WHOIS contact data.

Rowfeed

Domain Intel — DNS, WHOIS/RDAP, SSL & mail posture

titian_troupe/domain-intel

Bulk domain enrichment: A/AAAA/MX/NS/TXT records, registrar and domain age via RDAP, SSL certificate issuer and expiry, plus mail provider, SPF and DMARC detection. No API keys required.

Rumblingb

WHOIS & DNS Lookup - Domain Age, Expiry, SSL & DMARC

kantolabs/domain-whois-dns-ssl-lookup

Bulk WHOIS/RDAP, DNS, SSL and email-security report per domain: registrar, creation and expiry dates, availability, all DNS records, certificate expiry and an SPF/DKIM/DMARC grade. $3 per 1,000 domains.

Kanto Labs

WHOIS RDAP & DNS Lookup — Bulk, Keyless

hipersoft/rdap-whois-dns-lookup

Bulk domain intelligence: WHOIS/RDAP registrar, creation/expiry dates and statuses plus full DNS records (A, AAAA, MX, NS, TXT, CNAME, SOA) for every domain. Keyless, no signup.

hiper soft

WHOIS Lookup: Domains, DNS, Expiry & Availability

glitchbound/whois-domain-lookup

Bulk WHOIS lookup for domains: registrar, registration and expiry dates, lock status, DNSSEC, nameservers and live DNS records (A, MX, NS, TXT, CAA). Detects the mail and DNS provider, checks SPF/DMARC, and tells you whether a domain is available. Official RDAP and DNS, no key.