The official WhoisFreaks Python SDK: a complete client for WHOIS, DNS, SSL, domain availability, subdomain, IP geolocation, IP reputation, ASN, typosquatting, and domain reputation lookups, plus bulk database downloads. Query real-time and historical domain data, reverse WHOIS, and threat intelligence from Python with a single API key. Generated from the WhoisFreaks OpenAPI specification and published to PyPI.
Keywords: python whois api, python whois sdk, whoisfreaks python, python domain lookup, python dns api, whois api, whois lookup, domain api, dns api, dns lookup, reverse whois, historical whois, domain availability api, ssl certificate api, ip geolocation api, ip reputation api, asn lookup, subdomain finder, typosquatting api, domain reputation, threat intelligence api, domain data api, whois sdk, domain monitoring, brand protection api
whoisfreakspip install whoisfreaks
Prefer to build the SDK yourself instead of installing from PyPI? Clone the Python SDK repository and build it locally:
git clone https://github.com/WhoisFreaks/whoisfreaks-python
cd whoisfreaks-python
pip install -e . # editable local install
A complete walkthrough from an empty directory to a running program:
mkdir whoisfreaks-test && cd whoisfreaks-test
python3 -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install whoisfreaks
main.py:import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
record = whoisfreaks.WHOISApi(client).whois_live("whoisfreaks.com")
print("Domain: ", record.domain_name)
print("Created:", record.create_date)
print("Expires:", record.expiry_date)
export WHOISFREAKS_API_KEY="your_api_key" # PowerShell: $env:WHOISFREAKS_API_KEY="your_api_key"
python main.py
See Authentication for how to obtain a key. Minimal setup:
"""Live WHOIS Lookup: GET https://api.whoisfreaks.com/v2.0/whois/live
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python WhoisLive.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.WHOISApi(client)
# whois_live parameters:
# domain_name (str, required)
# format (str, optional, keyword): one of json, xml; default "json"
result = api.whois_live("whoisfreaks.com")
print(json.dumps(result.to_dict(), indent=2))
All 94 endpoints are shown below, grouped by category. Each includes its method, path, parameters, and a runnable example. See the full endpoint reference for response shapes and field details.
GET /v2.0/whois/live
"""Live WHOIS Lookup: GET https://api.whoisfreaks.com/v2.0/whois/live
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python WhoisLive.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.WHOISApi(client)
# whois_live parameters:
# domain_name (str, required)
# format (str, optional, keyword): one of json, xml; default "json"
result = api.whois_live("whoisfreaks.com")
print(json.dumps(result.to_dict(), indent=2))
POST /v2.0/bulkwhois/live
"""Bulk WHOIS Lookup: POST https://api.whoisfreaks.com/v2.0/bulkwhois/live
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python BulkWhois.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.WHOISApi(client)
# bulk_whois parameters:
# bulk_whois_request (BulkWhoisRequest, required): request body
# format (str, optional, keyword): one of json, xml; default "json"
body = whoisfreaks.BulkWhoisRequest(domain_names=["whoisfreaks.com", "jfreaks.com"])
result = api.bulk_whois(body)
print(json.dumps(result.to_dict(), indent=2))
GET /v2.0/whois/history
"""Historical WHOIS records for a domain: GET https://api.whoisfreaks.com/v2.0/whois/history
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python WhoisHistory.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.WHOISApi(client)
# whois_history parameters:
# domain_name (str, required): Domain to fetch historical WHOIS records for
# format (str, optional, keyword): one of json, xml
result = api.whois_history("whoisfreaks.com")
print(json.dumps(result.to_dict(), indent=2))
GET /v2.0/whois/reverse
"""Reverse WHOIS lookup by keyword: GET https://api.whoisfreaks.com/v2.0/whois/reverse
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python WhoisReverse.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.WHOISApi(client)
# whois_reverse parameters:
# keyword (str, required): Keyword to search across WHOIS records
# page (int, optional, keyword): Page number
# format (str, optional, keyword): one of json, xml
result = api.whois_reverse("whoisfreaks", page=1)
print(json.dumps(result.to_dict(), indent=2))
GET /v2.0/dns/live
"""Live DNS Lookup: GET https://api.whoisfreaks.com/v2.0/dns/live
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DnsLive.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DNSApi(client)
# dns_live parameters:
# type (str, required): all or comma-separated: A,MX,NS,TXT,SOA,SPF,AAAA,CNAME; default "all"
# domain_name (str, optional, keyword)
# ip_address (str, optional, keyword): Use for PTR lookups
# format (str, optional, keyword): one of json, xml; default "json"
result = api.dns_live("A,MX,TXT", domain_name="whoisfreaks.com")
print(json.dumps(result.to_dict(), indent=2))
GET /v2.0/dns/historical
"""Historical DNS Lookup: GET https://api.whoisfreaks.com/v2.0/dns/historical
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DnsHistorical.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DNSApi(client)
# dns_historical parameters:
# domain_name (str, required)
# type (str, required): default "all"
# page (int, optional, keyword): default 1
# format (str, optional, keyword): one of json, xml; default "json"
result = api.dns_historical("whoisfreaks.com", "A,MX,TXT", page=1)
print(json.dumps(result.to_dict(), indent=2))
GET /v2.1/dns/reverse
"""Reverse DNS Lookup: GET https://api.whoisfreaks.com/v2.1/dns/reverse
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DnsReverse.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DNSApi(client)
# dns_reverse parameters:
# value (str, required): IP, CIDR, or record value
# type (str, required): one of a, mx, cname, ns, aaaa, txt, soa
# exact (bool, optional, keyword): default True
# page (int, optional, keyword): default 1
# format (str, optional, keyword): one of json, xml; default "json"
result = api.dns_reverse("8.8.8.8", "a", page=1)
print(json.dumps(result.to_dict(), indent=2))
GET /v2.2/dns/historical
"""Historical DNS Lookup (v2.2): GET https://api.whoisfreaks.com/v2.2/dns/historical
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DnsHistoricalV22.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DNSApi(client)
# dns_historical_v22 parameters:
# domain_name (str, required)
# type (str, required): default "all"
# page (int, optional, keyword): default 1
# sort (str, optional, keyword): Sort direction. Omit to leave the results unsorted; one of asc, desc
# sort_by (str, optional, keyword): Field to sort on. Only applies when sort is given; one of firstSeen, lastSeen; default "lastSeen"
# format (str, optional, keyword): one of json, xml; default "json"
result = api.dns_historical_v22("whoisfreaks.com", "A,MX,TXT", page=1)
print(json.dumps(result.to_dict(), indent=2))
GET /v2.3/dns/historical
"""Historical DNS Lookup (v2.3): GET https://api.whoisfreaks.com/v2.3/dns/historical
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DnsHistoricalV23.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DNSApi(client)
# dns_historical_v23 parameters:
# domain_name (str, required)
# type (str, required): default "all"
# page (int, optional, keyword): default 1
# sort (str, optional, keyword): Sort direction. Omit to leave the results unsorted; one of asc, desc
# sort_by (str, optional, keyword): Field to sort on. Only applies when sort is given; one of firstSeen, lastSeen; default "lastSeen"
# format (str, optional, keyword): one of json, xml; default "json"
result = api.dns_historical_v23("whoisfreaks.com", "A,MX,TXT", page=1)
print(json.dumps(result.to_dict(), indent=2))
GET /v2.2/dns/reverse
"""Reverse DNS Lookup (v2.2): GET https://api.whoisfreaks.com/v2.2/dns/reverse
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DnsReverseV22.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DNSApi(client)
# dns_reverse_v22 parameters:
# value (str, required): IP, CIDR, or record value
# type (str, required): one of a, mx, cname, ns, aaaa, txt, soa
# exact (bool, optional, keyword): When false the value is matched as a substring, which is far slower than an e...; default True
# page (int, optional, keyword): default 1
# sort (str, optional, keyword): Sort direction. Omit to leave the results unsorted; one of asc, desc
# sort_by (str, optional, keyword): Field to sort on. Only applies when sort is given; one of firstSeen, lastSeen; default "lastSeen"
# format (str, optional, keyword): one of json, xml; default "json"
result = api.dns_reverse_v22("8.8.8.8", "a", page=1)
print(json.dumps(result.to_dict(), indent=2))
GET /v2.3/dns/reverse
"""Reverse DNS Lookup (v2.3): GET https://api.whoisfreaks.com/v2.3/dns/reverse
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DnsReverseV23.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DNSApi(client)
# dns_reverse_v23 parameters:
# value (str, required): IP, CIDR, or record value
# type (str, required): one of a, mx, cname, ns, aaaa, txt, soa
# exact (bool, optional, keyword): When false the value is matched as a substring, which is far slower than an e...; default True
# page (int, optional, keyword): default 1
# sort (str, optional, keyword): Sort direction. Omit to leave the results unsorted; one of asc, desc
# sort_by (str, optional, keyword): Field to sort on. Only applies when sort is given; one of firstSeen, lastSeen; default "lastSeen"
# format (str, optional, keyword): one of json, xml; default "json"
result = api.dns_reverse_v23("8.8.8.8", "a", page=1)
print(json.dumps(result.to_dict(), indent=2))
POST /v2.0/dns/bulk/live
"""Bulk DNS Lookup: POST https://api.whoisfreaks.com/v2.0/dns/bulk/live
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DnsBulk.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DNSApi(client)
# dns_bulk parameters:
# type (str, required): default "all"
# dns_bulk_request (DnsBulkRequest, required): request body
# format (str, optional, keyword): one of json, xml; default "json"
body = whoisfreaks.DnsBulkRequest(domain_names=["whoisfreaks.com", "example.com"])
result = api.dns_bulk("A,MX,TXT", body)
print(json.dumps(result.to_dict(), indent=2))
GET /v2.0/domain/availability
"""Domain Availability Check with Suggestions: GET https://api.whoisfreaks.com/v2.0/domain/availability
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DomainAvailabilityV2.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DomainAvailabilityApi(client)
# domain_availability_v2 parameters:
# domain (str, required): The domain name to check
# sug (bool, optional, keyword): Whether to return TLD suggestions alongside the queried domain; default False
# count (int, optional, keyword): Number of TLD suggestions to return when sug=true. Maximum is 100; default 5
# format (str, optional, keyword): one of json, xml; default "json"
result = api.domain_availability_v2("google.com", sug=True, count=5)
print(json.dumps(result.to_dict(), indent=2))
POST /v2.0/domain/availability
"""Bulk Domain Availability Check: POST https://api.whoisfreaks.com/v2.0/domain/availability
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python BulkDomainAvailabilityV2.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DomainAvailabilityApi(client)
# bulk_domain_availability_v2 parameters:
# bulk_domain_availability_request (BulkDomainAvailabilityRequest, required): request body
# domain (str, optional, keyword): Required for TLD-mode bulk check (base domain)
# format (str, optional, keyword): one of json, xml; default "json"
body = whoisfreaks.BulkDomainAvailabilityRequest(domain_names=["whoisfreaks.com", "example.com"])
result = api.bulk_domain_availability_v2(body)
print(json.dumps(result.to_dict(), indent=2))
GET /v3.0/domain/typos
"""Typosquatting Lookup: GET https://api.whoisfreaks.com/v3.0/domain/typos
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python Typosquatting.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.TyposquattingApi(client)
# typosquatting parameters:
# keyword (str, optional, keyword)
# pattern (str, optional, keyword)
# page_token (str, optional, keyword)
result = api.typosquatting(keyword="whoisfreaks")
print(json.dumps(result.to_dict(), indent=2))
GET /v1.0/ssl/live
"""SSL Certificate Lookup: GET https://api.whoisfreaks.com/v1.0/ssl/live
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python SslLookup.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.SSLApi(client)
# ssl_lookup parameters:
# domain_name (str, required)
# chain (bool, optional, keyword): default False
# ssl_raw (bool, optional, keyword): default False
# format (str, optional, keyword): one of json, xml; default "json"
result = api.ssl_lookup("whoisfreaks.com")
print(json.dumps(result.to_dict(), indent=2))
GET /v1.0/geolocation
"""IP Geolocation Lookup: GET https://api.whoisfreaks.com/v1.0/geolocation
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python Geolocation.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.GeolocationApi(client)
# geolocation parameters:
# ip (str, required)
result = api.geolocation("8.8.8.8")
print(json.dumps(result.to_dict(), indent=2))
POST /v1.0/geolocation
"""Bulk IP Geolocation: POST https://api.whoisfreaks.com/v1.0/geolocation
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python BulkGeolocation.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.GeolocationApi(client)
# bulk_geolocation parameters:
# bulk_geolocation_request (BulkGeolocationRequest, required): request body
body = whoisfreaks.BulkGeolocationRequest(ips=["8.8.8.8", "1.1.1.1"])
results = api.bulk_geolocation(body)
print(json.dumps([item.to_dict() for item in results], indent=2))
GET /v1.0/subdomains
"""Subdomains Lookup: GET https://api.whoisfreaks.com/v1.0/subdomains
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python Subdomains.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.SubdomainsApi(client)
# subdomains parameters:
# domain (str, required)
# after (datetime.date, optional, keyword)
# before (datetime.date, optional, keyword)
# status (str, optional, keyword): one of active, inactive
# page (int, optional, keyword): default 1
# format (str, optional, keyword): one of json, xml; default "json"
result = api.subdomains("whoisfreaks.com", page=1)
print(json.dumps(result.to_dict(), indent=2))
GET /v1.0/security
"""IP Reputation Lookup: GET https://api.whoisfreaks.com/v1.0/security
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python IpReputation.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.IPReputationApi(client)
# ip_reputation parameters:
# ip (str, required)
result = api.ip_reputation("8.8.8.8")
print(json.dumps(result.to_dict(), indent=2))
POST /v1.0/security
"""Bulk IP Reputation: POST https://api.whoisfreaks.com/v1.0/security
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python BulkIpReputation.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.IPReputationApi(client)
# bulk_ip_reputation parameters:
# bulk_geolocation_request (BulkGeolocationRequest, required): request body
body = whoisfreaks.BulkGeolocationRequest(ips=["8.8.8.8", "1.1.1.1"])
results = api.bulk_ip_reputation(body)
print(json.dumps([item.to_dict() for item in results], indent=2))
GET /v2.0/security
"""IP Reputation Lookup (v2.0): GET https://api.whoisfreaks.com/v2.0/security
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python IpReputationV2.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.IPReputationApi(client)
# ip_reputation_v2 parameters:
# ip (str, required)
result = api.ip_reputation_v2("8.8.8.8")
print(json.dumps(result.to_dict(), indent=2))
POST /v2.0/security
"""Bulk IP Reputation (v2.0): POST https://api.whoisfreaks.com/v2.0/security
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python BulkIpReputationV2.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.IPReputationApi(client)
# bulk_ip_reputation_v2 parameters:
# bulk_geolocation_request (BulkGeolocationRequest, required): request body
body = whoisfreaks.BulkGeolocationRequest(ips=["1.1.1.1", "2.2.2.2", "8.8.8.8"])
results = api.bulk_ip_reputation_v2(body)
print(json.dumps([item.to_dict() for item in results], indent=2))
GET /v1/domain/security
"""Domain Reputation Lookup: GET https://api.whoisfreaks.com/v1/domain/security
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DomainReputation.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DomainReputationApi(client)
# domain_reputation parameters:
# domain_name (str, required): The domain name to assess
# format (str, optional, keyword): one of json, xml; default "json"
result = api.domain_reputation("amazon.com")
print(json.dumps(result.to_dict(), indent=2))
GET /v2.0/asn-whois
"""ASN WHOIS Lookup: GET https://api.whoisfreaks.com/v2.0/asn-whois
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python AsnWhois.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.ASNWHOISApi(client)
# asn_whois parameters:
# asn (str, required)
# format (str, optional, keyword): one of json, xml; default "json"
result = api.asn_whois("as15169")
print(json.dumps(result.to_dict(), indent=2))
GET /v1.0/ip-whois
"""IP WHOIS Lookup: GET https://api.whoisfreaks.com/v1.0/ip-whois
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python IpWhois.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.IPWHOISApi(client)
# ip_whois parameters:
# ip (str, required)
# format (str, optional, keyword): one of json, xml; default "json"
result = api.ip_whois("8.8.8.8")
print(json.dumps(result.to_dict(), indent=2))
GET /v1.0/api-key/rotate
"""Rotate API Key: GET https://api.whoisfreaks.com/v1.0/api-key/rotate
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python RotateApiKey.py
"""
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.AccountApi(client)
# rotate_api_key takes no parameters.
new_key = api.rotate_api_key() # use this key from now on
print("New API key:", new_key)
GET /v1.0/whoisapi/usage
"""Account Usage: GET https://api.whoisfreaks.com/v1.0/whoisapi/usage
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python AccountUsage.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.AccountApi(client)
# account_usage takes no parameters.
result = api.account_usage()
print(json.dumps(result.to_dict(), indent=2))
GET /v3.4/status
"""Database File Status (Public): GET https://files.whoisfreaks.com/v3.4/status
Run it (public endpoint, no API key needed):
python DatabaseFileStatus.py
"""
import json
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.AccountApi(client)
# database_file_status takes no parameters.
result = api.database_file_status()
print(json.dumps(result.to_dict(), indent=2))
GET /v3.1/download/domainer/gtld
"""Newly Registered gTLD (CSV): GET https://files.whoisfreaks.com/v3.1/download/domainer/gtld
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbNewlyGtld.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesNewlyRegisteredApi(client)
# db_newly_gtld parameters:
# whois (bool, required)
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
# tlds (str, optional, keyword)
data = api.db_newly_gtld(True, var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbNewlyGtld.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.1/download/domainer/cctld
"""Newly Registered ccTLD (CSV): GET https://files.whoisfreaks.com/v3.1/download/domainer/cctld
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbNewlyCctld.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesNewlyRegisteredApi(client)
# db_newly_cctld parameters:
# whois (bool, required)
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
# tlds (str, optional, keyword)
data = api.db_newly_cctld(True, var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbNewlyCctld.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.1/download/domainer/gtld/cleaned
"""Newly Registered gTLD Cleaned WHOIS (CSV): GET https://files.whoisfreaks.com/v3.1/download/domainer/gtld/cleaned
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbNewlyGtldCleaned.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesNewlyRegisteredApi(client)
# db_newly_gtld_cleaned parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_newly_gtld_cleaned(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbNewlyGtldCleaned.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.1/download/domainer/cctld/cleaned
"""Newly Registered ccTLD Cleaned WHOIS (CSV): GET https://files.whoisfreaks.com/v3.1/download/domainer/cctld/cleaned
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbNewlyCctldCleaned.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesNewlyRegisteredApi(client)
# db_newly_cctld_cleaned parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_newly_cctld_cleaned(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbNewlyCctldCleaned.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.1/domains/newly/gtld
"""Newly Registered gTLD (JSON): GET https://files.whoisfreaks.com/v3.1/domains/newly/gtld
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbNewlyGtldJson.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesNewlyRegisteredApi(client)
# db_newly_gtld_json parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
# tlds (str, optional, keyword)
domains = api.db_newly_gtld_json(var_date=date(2026, 10, 1))
print(f"{len(domains)} domains")
print("\n".join(domains[:10]))
GET /v3.1/domains/newly/cctld
"""Newly Registered ccTLD (JSON): GET https://files.whoisfreaks.com/v3.1/domains/newly/cctld
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbNewlyCctldJson.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesNewlyRegisteredApi(client)
# db_newly_cctld_json parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
# tlds (str, optional, keyword)
domains = api.db_newly_cctld_json(var_date=date(2026, 10, 1))
print(f"{len(domains)} domains")
print("\n".join(domains[:10]))
GET /v3.1/download/domainer/newly/dns
"""Newly Registered With DNS: GET https://files.whoisfreaks.com/v3.1/download/domainer/newly/dns
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbNewlyDns.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesNewlyRegisteredApi(client)
# db_newly_dns parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_newly_dns(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbNewlyDns.json"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.1/download/domainer/expired
"""Expiring Domains: GET https://files.whoisfreaks.com/v3.1/download/domainer/expired
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbExpired.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesExpiringDroppedApi(client)
# db_expired parameters:
# whois (bool, required)
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_expired(True, var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbExpired.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.1/download/domainer/expired/cleaned
"""Expiring Cleaned WHOIS: GET https://files.whoisfreaks.com/v3.1/download/domainer/expired/cleaned
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbExpiredCleaned.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesExpiringDroppedApi(client)
# db_expired_cleaned parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_expired_cleaned(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbExpiredCleaned.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.1/download/domainer/dropped
"""Dropped Domains: GET https://files.whoisfreaks.com/v3.1/download/domainer/dropped
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbDropped.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesExpiringDroppedApi(client)
# db_dropped parameters:
# whois (bool, required)
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_dropped(True, var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbDropped.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.1/domains/dropped
"""Dropped Domains (JSON): GET https://files.whoisfreaks.com/v3.1/domains/dropped
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbDroppedJson.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesExpiringDroppedApi(client)
# db_dropped_json parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
# tlds (str, optional, keyword)
domains = api.db_dropped_json(var_date=date(2026, 10, 1))
print(f"{len(domains)} domains")
print("\n".join(domains[:10]))
GET /v3.3/download/domainer/dropped/backlinks
"""Dropped With Backlinks: GET https://files.whoisfreaks.com/v3.3/download/domainer/dropped/backlinks
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbDroppedBacklinks.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesExpiringDroppedApi(client)
# db_dropped_backlinks parameters:
# whois (bool, optional, keyword)
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_dropped_backlinks(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbDroppedBacklinks.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.3/download/dbupdate/daily/domains/whois
"""WHOIS Database Daily: GET https://files.whoisfreaks.com/v3.3/download/dbupdate/daily/domains/whois
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbWhoisDaily.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesWHOISApi(client)
# db_whois_daily parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_whois_daily(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbWhoisDaily.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.3/download/dbupdate/weekly/domains/whois
"""WHOIS Database Weekly: GET https://files.whoisfreaks.com/v3.3/download/dbupdate/weekly/domains/whois
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbWhoisWeekly.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesWHOISApi(client)
# db_whois_weekly parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_whois_weekly(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbWhoisWeekly.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.3/download/dbupdate/monthly/domains/whois
"""WHOIS Database Monthly: GET https://files.whoisfreaks.com/v3.3/download/dbupdate/monthly/domains/whois
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbWhoisMonthly.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesWHOISApi(client)
# db_whois_monthly parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_whois_monthly(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbWhoisMonthly.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.2/download/dbupdate/daily/dns
"""DNS Database Daily: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/daily/dns
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbDnsDaily.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesDNSApi(client)
# db_dns_daily parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_dns_daily(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbDnsDaily.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.2/download/dbupdate/weekly/dns
"""DNS Database Weekly: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/weekly/dns
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbDnsWeekly.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesDNSApi(client)
# db_dns_weekly parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_dns_weekly(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbDnsWeekly.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.2/download/dbupdate/monthly/dns
"""DNS Database Monthly: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/monthly/dns
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbDnsMonthly.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesDNSApi(client)
# db_dns_monthly parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_dns_monthly(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbDnsMonthly.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.2/download/dbupdate/daily/subdomains
"""Subdomains Daily: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/daily/subdomains
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbSubdomainsDaily.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesSubdomainsApi(client)
# db_subdomains_daily parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_subdomains_daily(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbSubdomainsDaily.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.2/download/dbupdate/weekly/subdomains
"""Subdomains Weekly: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/weekly/subdomains
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbSubdomainsWeekly.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesSubdomainsApi(client)
# db_subdomains_weekly parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_subdomains_weekly(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbSubdomainsWeekly.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.2/download/dbupdate/monthly/subdomains
"""Subdomains Monthly: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/monthly/subdomains
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbSubdomainsMonthly.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesSubdomainsApi(client)
# db_subdomains_monthly parameters:
# var_date (datetime.date, optional, keyword): yyyy-MM-dd; omit for latest
data = api.db_subdomains_monthly(var_date=date(2026, 10, 1)) # the file's raw bytes
path = "DbSubdomainsMonthly.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.3/status/snapshot/ip/country
"""IP to Country Snapshot Status: GET https://files.whoisfreaks.com/v3.3/status/snapshot/ip/country
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbIpCountryStatus.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesIPGeolocationApi(client)
# db_ip_country_status takes no parameters.
result = api.db_ip_country_status()
print(json.dumps(result.to_dict(), indent=2))
GET /v3.3/download/snapshot/ip/country
"""IP to Country Snapshot: GET https://files.whoisfreaks.com/v3.3/download/snapshot/ip/country
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbIpCountry.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesIPGeolocationApi(client)
# db_ip_country parameters:
# var_date (datetime.date, required)
data = api.db_ip_country(date(2026, 10, 1)) # the file's raw bytes
path = "DbIpCountry.zip"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.3/status/snapshot/ip/city
"""IP to City Snapshot Status: GET https://files.whoisfreaks.com/v3.3/status/snapshot/ip/city
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbIpCityStatus.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesIPGeolocationApi(client)
# db_ip_city_status takes no parameters.
result = api.db_ip_city_status()
print(json.dumps(result.to_dict(), indent=2))
GET /v3.3/download/snapshot/ip/city
"""IP to City Snapshot: GET https://files.whoisfreaks.com/v3.3/download/snapshot/ip/city
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbIpCity.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesIPGeolocationApi(client)
# db_ip_city parameters:
# var_date (datetime.date, required)
data = api.db_ip_city(date(2026, 10, 1)) # the file's raw bytes
path = "DbIpCity.zip"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.3/download/snapshot/asn/whois
"""ASN WHOIS Snapshot: GET https://files.whoisfreaks.com/v3.3/download/snapshot/asn/whois
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbAsnWhois.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesASNWHOISApi(client)
# db_asn_whois parameters:
# var_date (datetime.date, required)
data = api.db_asn_whois(date(2026, 10, 1)) # the file's raw bytes
path = "DbAsnWhois.json.gz"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.3/status/snapshot/asn/whois
"""ASN WHOIS Snapshot Status: GET https://files.whoisfreaks.com/v3.3/status/snapshot/asn/whois
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbAsnWhoisStatus.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesASNWHOISApi(client)
# db_asn_whois_status takes no parameters.
result = api.db_asn_whois_status()
print(json.dumps(result.to_dict(), indent=2))
GET /v3.3/download/snapshot/ip/whois
"""IP WHOIS Snapshot: GET https://files.whoisfreaks.com/v3.3/download/snapshot/ip/whois
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbIpWhois.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesIPWHOISApi(client)
# db_ip_whois parameters:
# var_date (datetime.date, required)
data = api.db_ip_whois(date(2026, 10, 1)) # the file's raw bytes
path = "DbIpWhois.json.gz"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.3/status/snapshot/ip/whois
"""IP WHOIS Snapshot Status: GET https://files.whoisfreaks.com/v3.3/status/snapshot/ip/whois
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbIpWhoisStatus.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesIPWHOISApi(client)
# db_ip_whois_status takes no parameters.
result = api.db_ip_whois_status()
print(json.dumps(result.to_dict(), indent=2))
GET /v3.3/download/snapshot/ip/security
"""IP Security Snapshot: GET https://files.whoisfreaks.com/v3.3/download/snapshot/ip/security
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbIpSecurity.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesIPSecurityApi(client)
# db_ip_security parameters:
# var_date (datetime.date, required)
data = api.db_ip_security(date(2026, 10, 1)) # the file's raw bytes
path = "DbIpSecurity.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.3/status/snapshot/ip/security
"""IP Security Snapshot Status: GET https://files.whoisfreaks.com/v3.3/status/snapshot/ip/security
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DbIpSecurityStatus.py
"""
import json
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesIPSecurityApi(client)
# db_ip_security_status takes no parameters.
result = api.db_ip_security_status()
print(json.dumps(result.to_dict(), indent=2))
GET /v3.4/download/threat-feed/phishing
"""Download the daily phishing threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/download/threat-feed/phishing
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DownloadThreatFeedPhishing.py
"""
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesThreatFeedApi(client)
# download_threat_feed_phishing parameters:
# var_date (str, optional, keyword): Feed date (yyyy-MM-dd); omit for the full dump of the feed
data = api.download_threat_feed_phishing(var_date="2026-10-01") # the file's raw bytes
path = "DownloadThreatFeedPhishing.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.4/download/threat-feed/phishing/sample
"""Download a sample of the phishing threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/download/threat-feed/phishing/sample
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DownloadThreatFeedPhishingSample.py
"""
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesThreatFeedApi(client)
# download_threat_feed_phishing_sample takes no parameters.
data = api.download_threat_feed_phishing_sample() # the file's raw bytes
path = "DownloadThreatFeedPhishingSample.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.4/download/threat-feed/malware
"""Download the daily malware threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/download/threat-feed/malware
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DownloadThreatFeedMalware.py
"""
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesThreatFeedApi(client)
# download_threat_feed_malware parameters:
# var_date (str, optional, keyword): Feed date (yyyy-MM-dd); omit for the full dump of the feed
data = api.download_threat_feed_malware(var_date="2026-10-01") # the file's raw bytes
path = "DownloadThreatFeedMalware.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.4/download/threat-feed/malware/sample
"""Download a sample of the malware threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/download/threat-feed/malware/sample
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DownloadThreatFeedMalwareSample.py
"""
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesThreatFeedApi(client)
# download_threat_feed_malware_sample takes no parameters.
data = api.download_threat_feed_malware_sample() # the file's raw bytes
path = "DownloadThreatFeedMalwareSample.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.4/download/threat-feed/spam
"""Download the daily spam threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/download/threat-feed/spam
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DownloadThreatFeedSpam.py
"""
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesThreatFeedApi(client)
# download_threat_feed_spam parameters:
# var_date (str, optional, keyword): Feed date (yyyy-MM-dd); omit for the full dump of the feed
data = api.download_threat_feed_spam(var_date="2026-10-01") # the file's raw bytes
path = "DownloadThreatFeedSpam.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.4/download/threat-feed/spam/sample
"""Download a sample of the spam threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/download/threat-feed/spam/sample
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python DownloadThreatFeedSpamSample.py
"""
import os
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesThreatFeedApi(client)
# download_threat_feed_spam_sample takes no parameters.
data = api.download_threat_feed_spam_sample() # the file's raw bytes
path = "DownloadThreatFeedSpamSample.csv"
with open(path, "wb") as f:
f.write(data)
print(f"Saved {len(data)} bytes to {os.path.abspath(path)}")
GET /v3.4/stream/threat-feed/phishing
"""Stream the daily phishing threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/phishing
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamThreatFeedPhishing.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_phishing parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_phishing(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.4/stream/threat-feed/phishing/sample
"""Stream a sample of the phishing threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/phishing/sample
Run it (public endpoint, no API key needed):
python StreamThreatFeedPhishingSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_phishing_sample parameters:
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_phishing_sample() # plain CSV text, already decompressed
print(csv_text)
GET /v3.4/stream/threat-feed/malware
"""Stream the daily malware threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/malware
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamThreatFeedMalware.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_malware parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_malware(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.4/stream/threat-feed/malware/sample
"""Stream a sample of the malware threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/malware/sample
Run it (public endpoint, no API key needed):
python StreamThreatFeedMalwareSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_malware_sample parameters:
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_malware_sample() # plain CSV text, already decompressed
print(csv_text)
GET /v3.4/stream/threat-feed/spam
"""Stream the daily spam threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/spam
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamThreatFeedSpam.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_spam parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_spam(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.4/stream/threat-feed/spam/sample
"""Stream a sample of the spam threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/spam/sample
Run it (public endpoint, no API key needed):
python StreamThreatFeedSpamSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_spam_sample parameters:
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_spam_sample() # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/gtld
"""Stream newly registered gTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerGtld.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/gtld/cleaned
"""Stream cleaned newly registered gTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld/cleaned
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerGtldCleaned.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld_cleaned parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld_cleaned(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/gtld/cleaned/email
"""Stream cleaned newly registered gTLD domains with an email (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld/cleaned/email
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerGtldCleanedEmail.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld_cleaned_email parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld_cleaned_email(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/gtld/cleaned/phone
"""Stream cleaned newly registered gTLD domains with a phone (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld/cleaned/phone
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerGtldCleanedPhone.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld_cleaned_phone parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld_cleaned_phone(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/cctld
"""Stream newly registered ccTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerCctld.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/cctld/cleaned
"""Stream cleaned newly registered ccTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld/cleaned
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerCctldCleaned.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld_cleaned parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld_cleaned(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/cctld/cleaned/email
"""Stream cleaned newly registered ccTLD domains with an email (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld/cleaned/email
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerCctldCleanedEmail.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld_cleaned_email parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld_cleaned_email(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/cctld/cleaned/phone
"""Stream cleaned newly registered ccTLD domains with a phone (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld/cleaned/phone
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerCctldCleanedPhone.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld_cleaned_phone parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld_cleaned_phone(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/expired
"""Stream expiring domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerExpired.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/expired/cleaned
"""Stream cleaned expiring domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired/cleaned
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerExpiredCleaned.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired_cleaned parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired_cleaned(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/expired/cleaned/email
"""Stream cleaned expiring domains with an email (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired/cleaned/email
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerExpiredCleanedEmail.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired_cleaned_email parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired_cleaned_email(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/expired/cleaned/phone
"""Stream cleaned expiring domains with a phone (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired/cleaned/phone
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerExpiredCleanedPhone.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired_cleaned_phone parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired_cleaned_phone(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/dropped
"""Stream dropped domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/dropped
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerDropped.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_dropped parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_dropped(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/dropped/backlinks
"""Stream dropped domains with backlinks (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/dropped/backlinks
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerDroppedBacklinks.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_dropped_backlinks parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_dropped_backlinks(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/sample/gtld
"""Stream a sample of newly registered gTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/gtld
Run it (public endpoint, no API key needed):
python StreamDomainerGtldSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld_sample() # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/sample/gtld/cleaned
"""Stream a sample of cleaned newly registered gTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/gtld/cleaned
Run it (public endpoint, no API key needed):
python StreamDomainerGtldCleanedSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld_cleaned_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld_cleaned_sample() # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/sample/cctld
"""Stream a sample of newly registered ccTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/cctld
Run it (public endpoint, no API key needed):
python StreamDomainerCctldSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld_sample() # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/sample/cctld/cleaned
"""Stream a sample of cleaned newly registered ccTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/cctld/cleaned
Run it (public endpoint, no API key needed):
python StreamDomainerCctldCleanedSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld_cleaned_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld_cleaned_sample() # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/sample/expired
"""Stream a sample of expiring domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/expired
Run it (public endpoint, no API key needed):
python StreamDomainerExpiredSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired_sample() # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/sample/expired/cleaned
"""Stream a sample of cleaned expiring domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/expired/cleaned
Run it (public endpoint, no API key needed):
python StreamDomainerExpiredCleanedSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired_cleaned_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired_cleaned_sample() # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/sample/dropped
"""Stream a sample of dropped domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/dropped
Run it (public endpoint, no API key needed):
python StreamDomainerDroppedSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_dropped_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_dropped_sample() # plain CSV text, already decompressed
print(csv_text)
GET /v3.3/stream/domainer/sample/dropped/backlinks
"""Stream a sample of dropped domains with backlinks (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/dropped/backlinks
Run it (public endpoint, no API key needed):
python StreamDomainerDroppedBacklinksSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_dropped_backlinks_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_dropped_backlinks_sample() # plain CSV text, already decompressed
print(csv_text)