The official WhoisFreaks TypeScript 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 TypeScript with a single API key. Generated from the WhoisFreaks OpenAPI specification and published to npm.
Keywords: typescript whois api, typescript whois sdk, whoisfreaks typescript, typescript domain lookup, typescript 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
whoisfreaksnpm install whoisfreaks
Prefer to build the SDK yourself instead of installing from npm? Clone the TypeScript SDK repository and build it locally:
git clone https://github.com/WhoisFreaks/whoisfreaks-typescript
cd whoisfreaks-typescript
npm install
npm run build
A complete walkthrough from an empty directory to a running program:
mkdir whoisfreaks-test && cd whoisfreaks-test
npm init -y
npm install whoisfreaks
npm install -D tsx @types/node
main.ts:import { Configuration, WHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new WHOISApi(config);
async function main(): Promise<void> {
const record = await api.whoisLive({ domainName: "whoisfreaks.com" });
console.log("Domain: ", record.domain_name);
console.log("Created:", record.create_date);
console.log("Expires:", record.expiry_date);
}
main().catch(async (err: unknown) => {
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
export WHOISFREAKS_API_KEY="your_api_key" # PowerShell: $env:WHOISFREAKS_API_KEY="your_api_key"
npx tsx main.ts
tsx runs the file without a separate compile step. To type-check as well, add the compiler and run it in strict mode:
npm install -D typescript
npx tsc --noEmit --strict --module nodenext --types node main.ts
See Authentication for how to obtain a key. Minimal setup:
// Live WHOIS Lookup: GET https://api.whoisfreaks.com/v2.0/whois/live
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx WhoisLive.ts
import { Configuration, WHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new WHOISApi(config);
// whoisLive({ domainName, format? })
// domainName (string, required)
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.whoisLive({ domainName: "whoisfreaks.com" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx WhoisLive.ts
import { Configuration, WHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new WHOISApi(config);
// whoisLive({ domainName, format? })
// domainName (string, required)
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.whoisLive({ domainName: "whoisfreaks.com" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
POST /v2.0/bulkwhois/live
// Bulk WHOIS Lookup: POST https://api.whoisfreaks.com/v2.0/bulkwhois/live
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx BulkWhois.ts
import { Configuration, WHOISApi, ResponseError, type BulkWhoisRequest } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new WHOISApi(config);
// bulkWhois({ bulkWhoisRequest, format? })
// bulkWhoisRequest (BulkWhoisRequest, required): request body
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const body: BulkWhoisRequest = { domainNames: ["whoisfreaks.com", "jfreaks.com"] };
const result = await api.bulkWhois({ bulkWhoisRequest: body });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.0/whois/history
// Historical WHOIS records for a domain: GET https://api.whoisfreaks.com/v2.0/whois/history
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx WhoisHistory.ts
import { Configuration, WHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new WHOISApi(config);
// whoisHistory({ domainName, format? })
// domainName (string, required): Domain to fetch historical WHOIS records for
// format ("json" | "xml", optional)
async function main(): Promise<void> {
const result = await api.whoisHistory({ domainName: "whoisfreaks.com" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.0/whois/reverse
// Reverse WHOIS lookup by keyword: GET https://api.whoisfreaks.com/v2.0/whois/reverse
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx WhoisReverse.ts
import { Configuration, WHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new WHOISApi(config);
// whoisReverse({ keyword, page?, format? })
// keyword (string, required): Keyword to search across WHOIS records
// page (number, optional): Page number
// format ("json" | "xml", optional)
async function main(): Promise<void> {
const result = await api.whoisReverse({ keyword: "whoisfreaks", page: 1 });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.0/dns/live
// Live DNS Lookup: GET https://api.whoisfreaks.com/v2.0/dns/live
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DnsLive.ts
import { Configuration, DNSApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DNSApi(config);
// dnsLive({ type, domainName?, ipAddress?, format? })
// type (string, required): all or comma-separated: A,MX,NS,TXT,SOA,SPF,AAAA,CNAME; default "all"
// domainName (string, optional)
// ipAddress (string, optional): Use for PTR lookups
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.dnsLive({ type: "A,MX,TXT", domainName: "whoisfreaks.com" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.0/dns/historical
// Historical DNS Lookup: GET https://api.whoisfreaks.com/v2.0/dns/historical
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DnsHistorical.ts
import { Configuration, DNSApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DNSApi(config);
// dnsHistorical({ domainName, type, page?, format? })
// domainName (string, required)
// type (string, required): default "all"
// page (number, optional): default 1
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.dnsHistorical({ domainName: "whoisfreaks.com", type: "A,MX,TXT", page: 1 });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.1/dns/reverse
// Reverse DNS Lookup: GET https://api.whoisfreaks.com/v2.1/dns/reverse
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DnsReverse.ts
import { Configuration, DNSApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DNSApi(config);
// dnsReverse({ value, type, exact?, page?, format? })
// value (string, required): IP, CIDR, or record value
// type ("a" | "mx" | "cname" | "ns" | "aaaa" | "txt" | "soa", required)
// exact (boolean, optional): default true
// page (number, optional): default 1
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.dnsReverse({ value: "8.8.8.8", type: "a", page: 1 });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.2/dns/historical
// Historical DNS Lookup (v2.2): GET https://api.whoisfreaks.com/v2.2/dns/historical
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DnsHistoricalV22.ts
import { Configuration, DNSApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DNSApi(config);
// dnsHistoricalV22({ domainName, type, page?, sort?, sortBy?, format? })
// domainName (string, required)
// type (string, required): default "all"
// page (number, optional): default 1
// sort ("asc" | "desc", optional): Sort direction. Omit to leave the results unsorted
// sortBy ("firstSeen" | "lastSeen", optional): Field to sort on. Only applies when sort is given; default "lastSeen"
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.dnsHistoricalV22({ domainName: "whoisfreaks.com", type: "A,MX,TXT", page: 1 });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.3/dns/historical
// Historical DNS Lookup (v2.3): GET https://api.whoisfreaks.com/v2.3/dns/historical
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DnsHistoricalV23.ts
import { Configuration, DNSApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DNSApi(config);
// dnsHistoricalV23({ domainName, type, page?, sort?, sortBy?, format? })
// domainName (string, required)
// type (string, required): default "all"
// page (number, optional): default 1
// sort ("asc" | "desc", optional): Sort direction. Omit to leave the results unsorted
// sortBy ("firstSeen" | "lastSeen", optional): Field to sort on. Only applies when sort is given; default "lastSeen"
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.dnsHistoricalV23({ domainName: "whoisfreaks.com", type: "A,MX,TXT", page: 1 });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.2/dns/reverse
// Reverse DNS Lookup (v2.2): GET https://api.whoisfreaks.com/v2.2/dns/reverse
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DnsReverseV22.ts
import { Configuration, DNSApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DNSApi(config);
// dnsReverseV22({ value, type, exact?, page?, sort?, sortBy?, format? })
// value (string, required): IP, CIDR, or record value
// type ("a" | "mx" | "cname" | "ns" | "aaaa" | "txt" | "soa", required)
// exact (boolean, optional): When false the value is matched as a substring, which is far slower than an e...; default true
// page (number, optional): default 1
// sort ("asc" | "desc", optional): Sort direction. Omit to leave the results unsorted
// sortBy ("firstSeen" | "lastSeen", optional): Field to sort on. Only applies when sort is given; default "lastSeen"
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.dnsReverseV22({ value: "8.8.8.8", type: "a", page: 1 });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.3/dns/reverse
// Reverse DNS Lookup (v2.3): GET https://api.whoisfreaks.com/v2.3/dns/reverse
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DnsReverseV23.ts
import { Configuration, DNSApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DNSApi(config);
// dnsReverseV23({ value, type, exact?, page?, sort?, sortBy?, format? })
// value (string, required): IP, CIDR, or record value
// type ("a" | "mx" | "cname" | "ns" | "aaaa" | "txt" | "soa", required)
// exact (boolean, optional): When false the value is matched as a substring, which is far slower than an e...; default true
// page (number, optional): default 1
// sort ("asc" | "desc", optional): Sort direction. Omit to leave the results unsorted
// sortBy ("firstSeen" | "lastSeen", optional): Field to sort on. Only applies when sort is given; default "lastSeen"
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.dnsReverseV23({ value: "8.8.8.8", type: "a", page: 1 });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
POST /v2.0/dns/bulk/live
// Bulk DNS Lookup: POST https://api.whoisfreaks.com/v2.0/dns/bulk/live
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DnsBulk.ts
import { Configuration, DNSApi, ResponseError, type DnsBulkRequest } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DNSApi(config);
// dnsBulk({ type, dnsBulkRequest, format? })
// type (string, required): default "all"
// dnsBulkRequest (DnsBulkRequest, required): request body
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const body: DnsBulkRequest = { domainNames: ["whoisfreaks.com", "example.com"] };
const result = await api.dnsBulk({ type: "A,MX,TXT", dnsBulkRequest: body });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.0/domain/availability
// Domain Availability Check with Suggestions: GET https://api.whoisfreaks.com/v2.0/domain/availability
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DomainAvailabilityV2.ts
import { Configuration, DomainAvailabilityApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DomainAvailabilityApi(config);
// domainAvailabilityV2({ domain, sug?, count?, format? })
// domain (string, required): The domain name to check
// sug (boolean, optional): Whether to return TLD suggestions alongside the queried domain; default false
// count (number, optional): Number of TLD suggestions to return when sug=true. Maximum is 100; default 5
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.domainAvailabilityV2({ domain: "google.com", sug: true, count: 5 });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
POST /v2.0/domain/availability
// Bulk Domain Availability Check: POST https://api.whoisfreaks.com/v2.0/domain/availability
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx BulkDomainAvailabilityV2.ts
import { Configuration, DomainAvailabilityApi, ResponseError, type BulkDomainAvailabilityRequest } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DomainAvailabilityApi(config);
// bulkDomainAvailabilityV2({ bulkDomainAvailabilityRequest, domain?, format? })
// bulkDomainAvailabilityRequest (BulkDomainAvailabilityRequest, required): request body
// domain (string, optional): Required for TLD-mode bulk check (base domain)
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const body: BulkDomainAvailabilityRequest = { domainNames: ["whoisfreaks.com", "example.com"] };
const result = await api.bulkDomainAvailabilityV2({ bulkDomainAvailabilityRequest: body });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.0/domain/typos
// Typosquatting Lookup: GET https://api.whoisfreaks.com/v3.0/domain/typos
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx Typosquatting.ts
import { Configuration, TyposquattingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new TyposquattingApi(config);
// typosquatting({ keyword?, pattern?, pageToken? })
// keyword (string, optional)
// pattern (string, optional)
// pageToken (string, optional)
async function main(): Promise<void> {
const result = await api.typosquatting({ keyword: "whoisfreaks" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v1.0/ssl/live
// SSL Certificate Lookup: GET https://api.whoisfreaks.com/v1.0/ssl/live
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx SslLookup.ts
import { Configuration, SSLApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new SSLApi(config);
// sslLookup({ domainName, chain?, sslRaw?, format? })
// domainName (string, required)
// chain (boolean, optional): default false
// sslRaw (boolean, optional): default false
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.sslLookup({ domainName: "whoisfreaks.com" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v1.0/geolocation
// IP Geolocation Lookup: GET https://api.whoisfreaks.com/v1.0/geolocation
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx Geolocation.ts
import { Configuration, GeolocationApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new GeolocationApi(config);
// geolocation({ ip })
// ip (string, required)
async function main(): Promise<void> {
const result = await api.geolocation({ ip: "8.8.8.8" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
POST /v1.0/geolocation
// Bulk IP Geolocation: POST https://api.whoisfreaks.com/v1.0/geolocation
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx BulkGeolocation.ts
import { Configuration, GeolocationApi, ResponseError, type BulkGeolocationRequest } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new GeolocationApi(config);
// bulkGeolocation({ bulkGeolocationRequest })
// bulkGeolocationRequest (BulkGeolocationRequest, required): request body
async function main(): Promise<void> {
const body: BulkGeolocationRequest = { ips: ["8.8.8.8", "1.1.1.1"] };
const results = await api.bulkGeolocation({ bulkGeolocationRequest: body });
console.log(JSON.stringify(results, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v1.0/subdomains
// Subdomains Lookup: GET https://api.whoisfreaks.com/v1.0/subdomains
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx Subdomains.ts
import { Configuration, SubdomainsApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new SubdomainsApi(config);
// subdomains({ domain, after?, before?, status?, page?, format? })
// domain (string, required)
// after (Date, optional)
// before (Date, optional)
// status ("active" | "inactive", optional)
// page (number, optional): default 1
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.subdomains({ domain: "whoisfreaks.com", page: 1 });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v1.0/security
// IP Reputation Lookup: GET https://api.whoisfreaks.com/v1.0/security
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx IpReputation.ts
import { Configuration, IPReputationApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new IPReputationApi(config);
// ipReputation({ ip })
// ip (string, required)
async function main(): Promise<void> {
const result = await api.ipReputation({ ip: "8.8.8.8" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
POST /v1.0/security
// Bulk IP Reputation: POST https://api.whoisfreaks.com/v1.0/security
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx BulkIpReputation.ts
import { Configuration, IPReputationApi, ResponseError, type BulkGeolocationRequest } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new IPReputationApi(config);
// bulkIpReputation({ bulkGeolocationRequest })
// bulkGeolocationRequest (BulkGeolocationRequest, required): request body
async function main(): Promise<void> {
const body: BulkGeolocationRequest = { ips: ["8.8.8.8", "1.1.1.1"] };
const results = await api.bulkIpReputation({ bulkGeolocationRequest: body });
console.log(JSON.stringify(results, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.0/security
// IP Reputation Lookup (v2.0): GET https://api.whoisfreaks.com/v2.0/security
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx IpReputationV2.ts
import { Configuration, IPReputationApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new IPReputationApi(config);
// ipReputationV2({ ip })
// ip (string, required)
async function main(): Promise<void> {
const result = await api.ipReputationV2({ ip: "8.8.8.8" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
POST /v2.0/security
// Bulk IP Reputation (v2.0): POST https://api.whoisfreaks.com/v2.0/security
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx BulkIpReputationV2.ts
import { Configuration, IPReputationApi, ResponseError, type BulkGeolocationRequest } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new IPReputationApi(config);
// bulkIpReputationV2({ bulkGeolocationRequest })
// bulkGeolocationRequest (BulkGeolocationRequest, required): request body
async function main(): Promise<void> {
const body: BulkGeolocationRequest = { ips: ["1.1.1.1", "2.2.2.2", "8.8.8.8"] };
const results = await api.bulkIpReputationV2({ bulkGeolocationRequest: body });
console.log(JSON.stringify(results, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v1/domain/security
// Domain Reputation Lookup: GET https://api.whoisfreaks.com/v1/domain/security
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DomainReputation.ts
import { Configuration, DomainReputationApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DomainReputationApi(config);
// domainReputation({ domainName, format? })
// domainName (string, required): The domain name to assess
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.domainReputation({ domainName: "amazon.com" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v2.0/asn-whois
// ASN WHOIS Lookup: GET https://api.whoisfreaks.com/v2.0/asn-whois
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx AsnWhois.ts
import { Configuration, ASNWHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new ASNWHOISApi(config);
// asnWhois({ asn, format? })
// asn (string, required)
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.asnWhois({ asn: "as15169" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v1.0/ip-whois
// IP WHOIS Lookup: GET https://api.whoisfreaks.com/v1.0/ip-whois
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx IpWhois.ts
import { Configuration, IPWHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new IPWHOISApi(config);
// ipWhois({ ip, format? })
// ip (string, required)
// format ("json" | "xml", optional): default "json"
async function main(): Promise<void> {
const result = await api.ipWhois({ ip: "8.8.8.8" });
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v1.0/api-key/rotate
// Rotate API Key: GET https://api.whoisfreaks.com/v1.0/api-key/rotate
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx RotateApiKey.ts
import { Configuration, AccountApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new AccountApi(config);
// rotateApiKey() takes no parameters.
async function main(): Promise<void> {
const newKey = await api.rotateApiKey(); // use this key from now on
console.log("New API key:", newKey);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v1.0/whoisapi/usage
// Account Usage: GET https://api.whoisfreaks.com/v1.0/whoisapi/usage
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx AccountUsage.ts
import { Configuration, AccountApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new AccountApi(config);
// accountUsage() takes no parameters.
async function main(): Promise<void> {
const result = await api.accountUsage();
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.4/status
// Database File Status (Public): GET https://files.whoisfreaks.com/v3.4/status
// Run (public endpoint, no API key needed): npx tsx DatabaseFileStatus.ts
import { AccountApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new AccountApi();
// databaseFileStatus() takes no parameters.
async function main(): Promise<void> {
const result = await api.databaseFileStatus();
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.1/download/domainer/gtld
// Newly Registered gTLD (CSV): GET https://files.whoisfreaks.com/v3.1/download/domainer/gtld
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbNewlyGtld.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesNewlyRegisteredApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesNewlyRegisteredApi(config);
// dbNewlyGtld({ whois, date?, tlds? })
// whois (boolean, required)
// date (Date, optional): yyyy-MM-dd; omit for latest
// tlds (string, optional)
async function main(): Promise<void> {
const blob = await api.dbNewlyGtld({ whois: true, date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbNewlyGtld.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.1/download/domainer/cctld
// Newly Registered ccTLD (CSV): GET https://files.whoisfreaks.com/v3.1/download/domainer/cctld
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbNewlyCctld.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesNewlyRegisteredApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesNewlyRegisteredApi(config);
// dbNewlyCctld({ whois, date?, tlds? })
// whois (boolean, required)
// date (Date, optional): yyyy-MM-dd; omit for latest
// tlds (string, optional)
async function main(): Promise<void> {
const blob = await api.dbNewlyCctld({ whois: true, date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbNewlyCctld.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx DbNewlyGtldCleaned.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesNewlyRegisteredApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesNewlyRegisteredApi(config);
// dbNewlyGtldCleaned({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbNewlyGtldCleaned({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbNewlyGtldCleaned.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx DbNewlyCctldCleaned.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesNewlyRegisteredApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesNewlyRegisteredApi(config);
// dbNewlyCctldCleaned({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbNewlyCctldCleaned({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbNewlyCctldCleaned.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.1/domains/newly/gtld
// Newly Registered gTLD (JSON): GET https://files.whoisfreaks.com/v3.1/domains/newly/gtld
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbNewlyGtldJson.ts
import { Configuration, DatabasesNewlyRegisteredApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesNewlyRegisteredApi(config);
// dbNewlyGtldJson({ date?, tlds? })
// date (Date, optional): yyyy-MM-dd; omit for latest
// tlds (string, optional)
async function main(): Promise<void> {
const domains = await api.dbNewlyGtldJson({ date: new Date("2026-10-01") });
console.log(`${domains.length} domains`);
console.log(domains.slice(0, 10).join("\n"));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.1/domains/newly/cctld
// Newly Registered ccTLD (JSON): GET https://files.whoisfreaks.com/v3.1/domains/newly/cctld
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbNewlyCctldJson.ts
import { Configuration, DatabasesNewlyRegisteredApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesNewlyRegisteredApi(config);
// dbNewlyCctldJson({ date?, tlds? })
// date (Date, optional): yyyy-MM-dd; omit for latest
// tlds (string, optional)
async function main(): Promise<void> {
const domains = await api.dbNewlyCctldJson({ date: new Date("2026-10-01") });
console.log(`${domains.length} domains`);
console.log(domains.slice(0, 10).join("\n"));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.1/download/domainer/newly/dns
// Newly Registered With DNS: GET https://files.whoisfreaks.com/v3.1/download/domainer/newly/dns
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbNewlyDns.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesNewlyRegisteredApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesNewlyRegisteredApi(config);
// dbNewlyDns({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbNewlyDns({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbNewlyDns.json";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.1/download/domainer/expired
// Expiring Domains: GET https://files.whoisfreaks.com/v3.1/download/domainer/expired
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbExpired.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesExpiringDroppedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesExpiringDroppedApi(config);
// dbExpired({ whois, date? })
// whois (boolean, required)
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbExpired({ whois: true, date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbExpired.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.1/download/domainer/expired/cleaned
// Expiring Cleaned WHOIS: GET https://files.whoisfreaks.com/v3.1/download/domainer/expired/cleaned
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbExpiredCleaned.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesExpiringDroppedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesExpiringDroppedApi(config);
// dbExpiredCleaned({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbExpiredCleaned({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbExpiredCleaned.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.1/download/domainer/dropped
// Dropped Domains: GET https://files.whoisfreaks.com/v3.1/download/domainer/dropped
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbDropped.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesExpiringDroppedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesExpiringDroppedApi(config);
// dbDropped({ whois, date? })
// whois (boolean, required)
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbDropped({ whois: true, date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbDropped.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.1/domains/dropped
// Dropped Domains (JSON): GET https://files.whoisfreaks.com/v3.1/domains/dropped
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbDroppedJson.ts
import { Configuration, DatabasesExpiringDroppedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesExpiringDroppedApi(config);
// dbDroppedJson({ date?, tlds? })
// date (Date, optional): yyyy-MM-dd; omit for latest
// tlds (string, optional)
async function main(): Promise<void> {
const domains = await api.dbDroppedJson({ date: new Date("2026-10-01") });
console.log(`${domains.length} domains`);
console.log(domains.slice(0, 10).join("\n"));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/download/domainer/dropped/backlinks
// Dropped With Backlinks: GET https://files.whoisfreaks.com/v3.3/download/domainer/dropped/backlinks
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbDroppedBacklinks.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesExpiringDroppedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesExpiringDroppedApi(config);
// dbDroppedBacklinks({ whois?, date? })
// whois (boolean, optional)
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbDroppedBacklinks({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbDroppedBacklinks.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/download/dbupdate/daily/domains/whois
// WHOIS Database Daily: GET https://files.whoisfreaks.com/v3.3/download/dbupdate/daily/domains/whois
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbWhoisDaily.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesWHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesWHOISApi(config);
// dbWhoisDaily({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbWhoisDaily({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbWhoisDaily.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/download/dbupdate/weekly/domains/whois
// WHOIS Database Weekly: GET https://files.whoisfreaks.com/v3.3/download/dbupdate/weekly/domains/whois
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbWhoisWeekly.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesWHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesWHOISApi(config);
// dbWhoisWeekly({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbWhoisWeekly({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbWhoisWeekly.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/download/dbupdate/monthly/domains/whois
// WHOIS Database Monthly: GET https://files.whoisfreaks.com/v3.3/download/dbupdate/monthly/domains/whois
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbWhoisMonthly.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesWHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesWHOISApi(config);
// dbWhoisMonthly({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbWhoisMonthly({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbWhoisMonthly.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.2/download/dbupdate/daily/dns
// DNS Database Daily: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/daily/dns
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbDnsDaily.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesDNSApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesDNSApi(config);
// dbDnsDaily({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbDnsDaily({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbDnsDaily.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.2/download/dbupdate/weekly/dns
// DNS Database Weekly: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/weekly/dns
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbDnsWeekly.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesDNSApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesDNSApi(config);
// dbDnsWeekly({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbDnsWeekly({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbDnsWeekly.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.2/download/dbupdate/monthly/dns
// DNS Database Monthly: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/monthly/dns
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbDnsMonthly.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesDNSApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesDNSApi(config);
// dbDnsMonthly({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbDnsMonthly({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbDnsMonthly.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.2/download/dbupdate/daily/subdomains
// Subdomains Daily: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/daily/subdomains
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbSubdomainsDaily.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesSubdomainsApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesSubdomainsApi(config);
// dbSubdomainsDaily({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbSubdomainsDaily({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbSubdomainsDaily.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.2/download/dbupdate/weekly/subdomains
// Subdomains Weekly: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/weekly/subdomains
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbSubdomainsWeekly.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesSubdomainsApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesSubdomainsApi(config);
// dbSubdomainsWeekly({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbSubdomainsWeekly({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbSubdomainsWeekly.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.2/download/dbupdate/monthly/subdomains
// Subdomains Monthly: GET https://files.whoisfreaks.com/v3.2/download/dbupdate/monthly/subdomains
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbSubdomainsMonthly.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesSubdomainsApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesSubdomainsApi(config);
// dbSubdomainsMonthly({ date? })
// date (Date, optional): yyyy-MM-dd; omit for latest
async function main(): Promise<void> {
const blob = await api.dbSubdomainsMonthly({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbSubdomainsMonthly.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/status/snapshot/ip/country
// IP to Country Snapshot Status: GET https://files.whoisfreaks.com/v3.3/status/snapshot/ip/country
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbIpCountryStatus.ts
import { Configuration, DatabasesIPGeolocationApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesIPGeolocationApi(config);
// dbIpCountryStatus() takes no parameters.
async function main(): Promise<void> {
const result = await api.dbIpCountryStatus();
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/download/snapshot/ip/country
// IP to Country Snapshot: GET https://files.whoisfreaks.com/v3.3/download/snapshot/ip/country
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbIpCountry.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesIPGeolocationApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesIPGeolocationApi(config);
// dbIpCountry({ date })
// date (Date, required)
async function main(): Promise<void> {
const blob = await api.dbIpCountry({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbIpCountry.zip";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/status/snapshot/ip/city
// IP to City Snapshot Status: GET https://files.whoisfreaks.com/v3.3/status/snapshot/ip/city
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbIpCityStatus.ts
import { Configuration, DatabasesIPGeolocationApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesIPGeolocationApi(config);
// dbIpCityStatus() takes no parameters.
async function main(): Promise<void> {
const result = await api.dbIpCityStatus();
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/download/snapshot/ip/city
// IP to City Snapshot: GET https://files.whoisfreaks.com/v3.3/download/snapshot/ip/city
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbIpCity.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesIPGeolocationApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesIPGeolocationApi(config);
// dbIpCity({ date })
// date (Date, required)
async function main(): Promise<void> {
const blob = await api.dbIpCity({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbIpCity.zip";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/download/snapshot/asn/whois
// ASN WHOIS Snapshot: GET https://files.whoisfreaks.com/v3.3/download/snapshot/asn/whois
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbAsnWhois.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesASNWHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesASNWHOISApi(config);
// dbAsnWhois({ date })
// date (Date, required)
async function main(): Promise<void> {
const blob = await api.dbAsnWhois({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbAsnWhois.json.gz";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/status/snapshot/asn/whois
// ASN WHOIS Snapshot Status: GET https://files.whoisfreaks.com/v3.3/status/snapshot/asn/whois
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbAsnWhoisStatus.ts
import { Configuration, DatabasesASNWHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesASNWHOISApi(config);
// dbAsnWhoisStatus() takes no parameters.
async function main(): Promise<void> {
const result = await api.dbAsnWhoisStatus();
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/download/snapshot/ip/whois
// IP WHOIS Snapshot: GET https://files.whoisfreaks.com/v3.3/download/snapshot/ip/whois
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbIpWhois.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesIPWHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesIPWHOISApi(config);
// dbIpWhois({ date })
// date (Date, required)
async function main(): Promise<void> {
const blob = await api.dbIpWhois({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbIpWhois.json.gz";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/status/snapshot/ip/whois
// IP WHOIS Snapshot Status: GET https://files.whoisfreaks.com/v3.3/status/snapshot/ip/whois
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbIpWhoisStatus.ts
import { Configuration, DatabasesIPWHOISApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesIPWHOISApi(config);
// dbIpWhoisStatus() takes no parameters.
async function main(): Promise<void> {
const result = await api.dbIpWhoisStatus();
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/download/snapshot/ip/security
// IP Security Snapshot: GET https://files.whoisfreaks.com/v3.3/download/snapshot/ip/security
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbIpSecurity.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesIPSecurityApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesIPSecurityApi(config);
// dbIpSecurity({ date })
// date (Date, required)
async function main(): Promise<void> {
const blob = await api.dbIpSecurity({ date: new Date("2026-10-01") }); // a Blob with the file's bytes
const file = "DbIpSecurity.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/status/snapshot/ip/security
// IP Security Snapshot Status: GET https://files.whoisfreaks.com/v3.3/status/snapshot/ip/security
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx DbIpSecurityStatus.ts
import { Configuration, DatabasesIPSecurityApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesIPSecurityApi(config);
// dbIpSecurityStatus() takes no parameters.
async function main(): Promise<void> {
const result = await api.dbIpSecurityStatus();
console.log(JSON.stringify(result, null, 2));
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx DownloadThreatFeedPhishing.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesThreatFeedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesThreatFeedApi(config);
// downloadThreatFeedPhishing({ date? })
// date (string, optional): Feed date (yyyy-MM-dd); omit for the full dump of the feed
async function main(): Promise<void> {
const blob = await api.downloadThreatFeedPhishing({ date: "2026-10-01" }); // a Blob with the file's bytes
const file = "DownloadThreatFeedPhishing.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx DownloadThreatFeedPhishingSample.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesThreatFeedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesThreatFeedApi(config);
// downloadThreatFeedPhishingSample() takes no parameters.
async function main(): Promise<void> {
const blob = await api.downloadThreatFeedPhishingSample(); // a Blob with the file's bytes
const file = "DownloadThreatFeedPhishingSample.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx DownloadThreatFeedMalware.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesThreatFeedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesThreatFeedApi(config);
// downloadThreatFeedMalware({ date? })
// date (string, optional): Feed date (yyyy-MM-dd); omit for the full dump of the feed
async function main(): Promise<void> {
const blob = await api.downloadThreatFeedMalware({ date: "2026-10-01" }); // a Blob with the file's bytes
const file = "DownloadThreatFeedMalware.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx DownloadThreatFeedMalwareSample.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesThreatFeedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesThreatFeedApi(config);
// downloadThreatFeedMalwareSample() takes no parameters.
async function main(): Promise<void> {
const blob = await api.downloadThreatFeedMalwareSample(); // a Blob with the file's bytes
const file = "DownloadThreatFeedMalwareSample.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx DownloadThreatFeedSpam.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesThreatFeedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesThreatFeedApi(config);
// downloadThreatFeedSpam({ date? })
// date (string, optional): Feed date (yyyy-MM-dd); omit for the full dump of the feed
async function main(): Promise<void> {
const blob = await api.downloadThreatFeedSpam({ date: "2026-10-01" }); // a Blob with the file's bytes
const file = "DownloadThreatFeedSpam.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx DownloadThreatFeedSpamSample.ts
import { writeFile } from "node:fs/promises";
import { resolve } from "node:path";
import { Configuration, DatabasesThreatFeedApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesThreatFeedApi(config);
// downloadThreatFeedSpamSample() takes no parameters.
async function main(): Promise<void> {
const blob = await api.downloadThreatFeedSpamSample(); // a Blob with the file's bytes
const file = "DownloadThreatFeedSpamSample.csv";
await writeFile(file, new Uint8Array(await blob.arrayBuffer()));
console.log(`Saved ${blob.size} bytes to ${resolve(file)}`);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamThreatFeedPhishing.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamThreatFeedPhishing({ date, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamThreatFeedPhishing({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamThreatFeedPhishingSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamThreatFeedPhishingSample({ offset?, limit? })
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamThreatFeedPhishingSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamThreatFeedMalware.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamThreatFeedMalware({ date, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamThreatFeedMalware({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamThreatFeedMalwareSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamThreatFeedMalwareSample({ offset?, limit? })
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamThreatFeedMalwareSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamThreatFeedSpam.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamThreatFeedSpam({ date, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamThreatFeedSpam({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamThreatFeedSpamSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamThreatFeedSpamSample({ offset?, limit? })
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamThreatFeedSpamSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/stream/domainer/gtld
// Stream newly registered gTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerGtld.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerGtld({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerGtld({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerGtldCleaned.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerGtldCleaned({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerGtldCleaned({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerGtldCleanedEmail.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerGtldCleanedEmail({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerGtldCleanedEmail({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerGtldCleanedPhone.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerGtldCleanedPhone({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerGtldCleanedPhone({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/stream/domainer/cctld
// Stream newly registered ccTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerCctld.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerCctld({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerCctld({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerCctldCleaned.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerCctldCleaned({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerCctldCleaned({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerCctldCleanedEmail.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerCctldCleanedEmail({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerCctldCleanedEmail({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerCctldCleanedPhone.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerCctldCleanedPhone({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerCctldCleanedPhone({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/stream/domainer/expired
// Stream expiring domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerExpired.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerExpired({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerExpired({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/stream/domainer/expired/cleaned
// Stream cleaned expiring domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired/cleaned
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerExpiredCleaned.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerExpiredCleaned({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerExpiredCleaned({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerExpiredCleanedEmail.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerExpiredCleanedEmail({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerExpiredCleanedEmail({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerExpiredCleanedPhone.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerExpiredCleanedPhone({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerExpiredCleanedPhone({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
GET /v3.3/stream/domainer/dropped
// Stream dropped domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/dropped
// Run: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerDropped.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerDropped({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerDropped({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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: WHOISFREAKS_API_KEY=your_api_key npx tsx StreamDomainerDroppedBacklinks.ts
import { Configuration, DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Set the API key once; the client adds it to every request.
const config = new Configuration({ apiKey: process.env.WHOISFREAKS_API_KEY });
const api = new DatabasesStreamingApi(config);
// streamDomainerDroppedBacklinks({ date, whois?, offset?, limit? })
// date (Date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerDroppedBacklinks({ date: new Date("2026-10-01") }); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamDomainerGtldSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamDomainerGtldSample({ whois?, offset?, limit? })
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerGtldSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamDomainerGtldCleanedSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamDomainerGtldCleanedSample({ whois?, offset?, limit? })
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerGtldCleanedSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamDomainerCctldSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamDomainerCctldSample({ whois?, offset?, limit? })
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerCctldSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamDomainerCctldCleanedSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamDomainerCctldCleanedSample({ whois?, offset?, limit? })
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerCctldCleanedSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamDomainerExpiredSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamDomainerExpiredSample({ whois?, offset?, limit? })
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerExpiredSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamDomainerExpiredCleanedSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamDomainerExpiredCleanedSample({ whois?, offset?, limit? })
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerExpiredCleanedSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamDomainerDroppedSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamDomainerDroppedSample({ whois?, offset?, limit? })
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerDroppedSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});
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 (public endpoint, no API key needed): npx tsx StreamDomainerDroppedBacklinksSample.ts
import { DatabasesStreamingApi, ResponseError } from "whoisfreaks";
// Public endpoint: no API key needed.
const api = new DatabasesStreamingApi();
// streamDomainerDroppedBacklinksSample({ whois?, offset?, limit? })
// whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false st...; default false
// offset (number, optional): Data rows to skip from the start of the file. The header row is never counted...
// limit (number, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
async function main(): Promise<void> {
const csvText = await api.streamDomainerDroppedBacklinksSample(); // plain CSV text, already decompressed
console.log(csvText);
}
main().catch(async (err: unknown) => {
// API errors carry the HTTP response
if (err instanceof ResponseError) {
console.error(`HTTP ${err.response.status}: ${await err.response.text()}`);
} else {
console.error(err);
}
process.exitCode = 1;
});