Databases - Streaming
Section: Databases
Stream database files and threat feeds as plain CSV text instead of downloading a gzip file
28 endpoints. Requests need your API key unless noted otherwise. See Authentication.
Stream the daily phishing threat feed (CSV)
GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/phishing
Streams the daily phishing threat feed for a given date. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
Parameters
| Parameter |
In |
Required |
Type |
Default |
Description |
date |
query |
yes |
string (date) |
|
yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
offset |
query |
no |
integer (int64) |
|
Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
limit |
query |
no |
integer (int64) |
|
Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
Usage
Python
```python
"""Stream the daily phishing threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/phishing
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamThreatFeedPhishing.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_phishing parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_phishing(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream the daily phishing threat feed (CSV) (GET /v3.4/stream/threat-feed/phishing)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamThreatFeedPhishing (GET /v3.4/stream/threat-feed/phishing):
// - date (string, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints.
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamThreatFeedPhishing(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of the phishing threat feed (CSV)
`GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/phishing/sample`
Public endpoint: no API key required.
Streams a fixed sample of the phishing threat feed. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of the phishing threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/phishing/sample
Run it (public endpoint, no API key needed):
python StreamThreatFeedPhishingSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_phishing_sample parameters:
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_phishing_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of the phishing threat feed (CSV) (GET /v3.4/stream/threat-feed/phishing/sample)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamThreatFeedPhishingSample (GET /v3.4/stream/threat-feed/phishing/sample):
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamThreatFeedPhishingSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream the daily malware threat feed (CSV)
`GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/malware`
Streams the daily malware threat feed for a given date. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream the daily malware threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/malware
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamThreatFeedMalware.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_malware parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_malware(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream the daily malware threat feed (CSV) (GET /v3.4/stream/threat-feed/malware)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamThreatFeedMalware (GET /v3.4/stream/threat-feed/malware):
// - date (string, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints.
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamThreatFeedMalware(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of the malware threat feed (CSV)
`GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/malware/sample`
Public endpoint: no API key required.
Streams a fixed sample of the malware threat feed. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of the malware threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/malware/sample
Run it (public endpoint, no API key needed):
python StreamThreatFeedMalwareSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_malware_sample parameters:
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_malware_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of the malware threat feed (CSV) (GET /v3.4/stream/threat-feed/malware/sample)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamThreatFeedMalwareSample (GET /v3.4/stream/threat-feed/malware/sample):
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamThreatFeedMalwareSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream the daily spam threat feed (CSV)
`GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/spam`
Streams the daily spam threat feed for a given date. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream the daily spam threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/spam
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamThreatFeedSpam.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_spam parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_spam(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream the daily spam threat feed (CSV) (GET /v3.4/stream/threat-feed/spam)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamThreatFeedSpam (GET /v3.4/stream/threat-feed/spam):
// - date (string, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints.
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamThreatFeedSpam(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of the spam threat feed (CSV)
`GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/spam/sample`
Public endpoint: no API key required.
Streams a fixed sample of the spam threat feed. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of the spam threat feed (CSV): GET https://files.whoisfreaks.com/v3.4/stream/threat-feed/spam/sample
Run it (public endpoint, no API key needed):
python StreamThreatFeedSpamSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_threat_feed_spam_sample parameters:
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_threat_feed_spam_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of the spam threat feed (CSV) (GET /v3.4/stream/threat-feed/spam/sample)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamThreatFeedSpamSample (GET /v3.4/stream/threat-feed/spam/sample):
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamThreatFeedSpamSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream newly registered gTLD domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld`
Streams the daily file of newly registered gTLD domains for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream newly registered gTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerGtld.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream newly registered gTLD domains (CSV) (GET /v3.3/stream/domainer/gtld)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerGtld (GET /v3.3/stream/domainer/gtld):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerGtld(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream cleaned newly registered gTLD domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld/cleaned`
Streams the daily file of cleaned newly registered gTLD domains for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream cleaned newly registered gTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld/cleaned
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerGtldCleaned.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld_cleaned parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld_cleaned(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream cleaned newly registered gTLD domains (CSV) (GET /v3.3/stream/domainer/gtld/cleaned)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerGtldCleaned (GET /v3.3/stream/domainer/gtld/cleaned):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerGtldCleaned(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream cleaned newly registered gTLD domains with an email (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld/cleaned/email`
Streams the daily file of cleaned newly registered gTLD domains with an email for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream cleaned newly registered gTLD domains with an email (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld/cleaned/email
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerGtldCleanedEmail.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld_cleaned_email parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld_cleaned_email(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream cleaned newly registered gTLD domains with an email (CSV) (GET /v3.3/stream/domainer/gtld/cleaned/email)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerGtldCleanedEmail (GET /v3.3/stream/domainer/gtld/cleaned/email):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerGtldCleanedEmail(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream cleaned newly registered gTLD domains with a phone (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld/cleaned/phone`
Streams the daily file of cleaned newly registered gTLD domains with a phone for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream cleaned newly registered gTLD domains with a phone (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/gtld/cleaned/phone
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerGtldCleanedPhone.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld_cleaned_phone parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld_cleaned_phone(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream cleaned newly registered gTLD domains with a phone (CSV) (GET /v3.3/stream/domainer/gtld/cleaned/phone)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerGtldCleanedPhone (GET /v3.3/stream/domainer/gtld/cleaned/phone):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerGtldCleanedPhone(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream newly registered ccTLD domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld`
Streams the daily file of newly registered ccTLD domains for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream newly registered ccTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerCctld.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream newly registered ccTLD domains (CSV) (GET /v3.3/stream/domainer/cctld)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerCctld (GET /v3.3/stream/domainer/cctld):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerCctld(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream cleaned newly registered ccTLD domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld/cleaned`
Streams the daily file of cleaned newly registered ccTLD domains for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream cleaned newly registered ccTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld/cleaned
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerCctldCleaned.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld_cleaned parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld_cleaned(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream cleaned newly registered ccTLD domains (CSV) (GET /v3.3/stream/domainer/cctld/cleaned)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerCctldCleaned (GET /v3.3/stream/domainer/cctld/cleaned):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerCctldCleaned(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream cleaned newly registered ccTLD domains with an email (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld/cleaned/email`
Streams the daily file of cleaned newly registered ccTLD domains with an email for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream cleaned newly registered ccTLD domains with an email (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld/cleaned/email
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerCctldCleanedEmail.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld_cleaned_email parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld_cleaned_email(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream cleaned newly registered ccTLD domains with an email (CSV) (GET /v3.3/stream/domainer/cctld/cleaned/email)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerCctldCleanedEmail (GET /v3.3/stream/domainer/cctld/cleaned/email):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerCctldCleanedEmail(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream cleaned newly registered ccTLD domains with a phone (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld/cleaned/phone`
Streams the daily file of cleaned newly registered ccTLD domains with a phone for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream cleaned newly registered ccTLD domains with a phone (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/cctld/cleaned/phone
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerCctldCleanedPhone.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld_cleaned_phone parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld_cleaned_phone(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream cleaned newly registered ccTLD domains with a phone (CSV) (GET /v3.3/stream/domainer/cctld/cleaned/phone)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerCctldCleanedPhone (GET /v3.3/stream/domainer/cctld/cleaned/phone):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerCctldCleanedPhone(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream expiring domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired`
Streams the daily file of expiring domains for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream expiring domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerExpired.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream expiring domains (CSV) (GET /v3.3/stream/domainer/expired)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerExpired (GET /v3.3/stream/domainer/expired):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerExpired(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream cleaned expiring domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired/cleaned`
Streams the daily file of cleaned expiring domains for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream cleaned expiring domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired/cleaned
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerExpiredCleaned.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired_cleaned parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired_cleaned(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream cleaned expiring domains (CSV) (GET /v3.3/stream/domainer/expired/cleaned)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerExpiredCleaned (GET /v3.3/stream/domainer/expired/cleaned):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerExpiredCleaned(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream cleaned expiring domains with an email (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired/cleaned/email`
Streams the daily file of cleaned expiring domains with an email for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream cleaned expiring domains with an email (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired/cleaned/email
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerExpiredCleanedEmail.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired_cleaned_email parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired_cleaned_email(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream cleaned expiring domains with an email (CSV) (GET /v3.3/stream/domainer/expired/cleaned/email)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerExpiredCleanedEmail (GET /v3.3/stream/domainer/expired/cleaned/email):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerExpiredCleanedEmail(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream cleaned expiring domains with a phone (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired/cleaned/phone`
Streams the daily file of cleaned expiring domains with a phone for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream cleaned expiring domains with a phone (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/expired/cleaned/phone
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerExpiredCleanedPhone.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired_cleaned_phone parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired_cleaned_phone(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream cleaned expiring domains with a phone (CSV) (GET /v3.3/stream/domainer/expired/cleaned/phone)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerExpiredCleanedPhone (GET /v3.3/stream/domainer/expired/cleaned/phone):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerExpiredCleanedPhone(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream dropped domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/dropped`
Streams the daily file of dropped domains for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream dropped domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/dropped
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerDropped.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_dropped parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_dropped(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream dropped domains (CSV) (GET /v3.3/stream/domainer/dropped)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerDropped (GET /v3.3/stream/domainer/dropped):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerDropped(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream dropped domains with backlinks (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/dropped/backlinks`
Streams the daily file of dropped domains with backlinks for a given date. Pass whois=true for the full WHOIS record with a CSV header, or whois=false for domain names only. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `date` | query | yes | string (date) | | yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints. |
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream dropped domains with backlinks (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/dropped/backlinks
Run it with your API key in the environment:
WHOISFREAKS_API_KEY=your_api_key python StreamDomainerDroppedBacklinks.py
"""
import os
from datetime import date
import whoisfreaks
config = whoisfreaks.Configuration()
config.api_key["ApiKeyAuth"] = os.environ["WHOISFREAKS_API_KEY"] # set once for every request
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_dropped_backlinks parameters:
# var_date (datetime.date, required): yyyy-MM-dd. Streaming always requires a date, unlike the download endpoints
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_dropped_backlinks(date(2026, 10, 1)) # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream dropped domains with backlinks (CSV) (GET /v3.3/stream/domainer/dropped/backlinks)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerDroppedBacklinks (GET /v3.3/stream/domainer/dropped/backlinks):
// - date (string, 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 streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Set the API key once on the context; every call made with ctx sends it.
ctx := context.WithValue(context.Background(), whoisfreaks.ContextAPIKeys,
map[string]whoisfreaks.APIKey{"ApiKeyAuth": {Key: os.Getenv("WHOISFREAKS_API_KEY")}})
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerDroppedBacklinks(ctx).
Date("2026-10-01").Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of newly registered gTLD domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/gtld`
Public endpoint: no API key required.
Streams a fixed sample of newly registered gTLD domains. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of newly registered gTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/gtld
Run it (public endpoint, no API key needed):
python StreamDomainerGtldSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of newly registered gTLD domains (CSV) (GET /v3.3/stream/domainer/sample/gtld)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerGtldSample (GET /v3.3/stream/domainer/sample/gtld):
// - whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerGtldSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of cleaned newly registered gTLD domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/gtld/cleaned`
Public endpoint: no API key required.
Streams a fixed sample of cleaned newly registered gTLD domains. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of cleaned newly registered gTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/gtld/cleaned
Run it (public endpoint, no API key needed):
python StreamDomainerGtldCleanedSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_gtld_cleaned_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_gtld_cleaned_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of cleaned newly registered gTLD domains (CSV) (GET /v3.3/stream/domainer/sample/gtld/cleaned)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerGtldCleanedSample (GET /v3.3/stream/domainer/sample/gtld/cleaned):
// - whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerGtldCleanedSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of newly registered ccTLD domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/cctld`
Public endpoint: no API key required.
Streams a fixed sample of newly registered ccTLD domains. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of newly registered ccTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/cctld
Run it (public endpoint, no API key needed):
python StreamDomainerCctldSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of newly registered ccTLD domains (CSV) (GET /v3.3/stream/domainer/sample/cctld)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerCctldSample (GET /v3.3/stream/domainer/sample/cctld):
// - whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerCctldSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of cleaned newly registered ccTLD domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/cctld/cleaned`
Public endpoint: no API key required.
Streams a fixed sample of cleaned newly registered ccTLD domains. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of cleaned newly registered ccTLD domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/cctld/cleaned
Run it (public endpoint, no API key needed):
python StreamDomainerCctldCleanedSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_cctld_cleaned_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_cctld_cleaned_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of cleaned newly registered ccTLD domains (CSV) (GET /v3.3/stream/domainer/sample/cctld/cleaned)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerCctldCleanedSample (GET /v3.3/stream/domainer/sample/cctld/cleaned):
// - whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerCctldCleanedSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of expiring domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/expired`
Public endpoint: no API key required.
Streams a fixed sample of expiring domains. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of expiring domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/expired
Run it (public endpoint, no API key needed):
python StreamDomainerExpiredSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of expiring domains (CSV) (GET /v3.3/stream/domainer/sample/expired)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerExpiredSample (GET /v3.3/stream/domainer/sample/expired):
// - whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerExpiredSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of cleaned expiring domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/expired/cleaned`
Public endpoint: no API key required.
Streams a fixed sample of cleaned expiring domains. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of cleaned expiring domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/expired/cleaned
Run it (public endpoint, no API key needed):
python StreamDomainerExpiredCleanedSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_expired_cleaned_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_expired_cleaned_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of cleaned expiring domains (CSV) (GET /v3.3/stream/domainer/sample/expired/cleaned)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerExpiredCleanedSample (GET /v3.3/stream/domainer/sample/expired/cleaned):
// - whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerExpiredCleanedSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of dropped domains (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/dropped`
Public endpoint: no API key required.
Streams a fixed sample of dropped domains. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of dropped domains (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/dropped
Run it (public endpoint, no API key needed):
python StreamDomainerDroppedSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_dropped_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_dropped_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of dropped domains (CSV) (GET /v3.3/stream/domainer/sample/dropped)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerDroppedSample (GET /v3.3/stream/domainer/sample/dropped):
// - whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerDroppedSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---
## Stream a sample of dropped domains with backlinks (CSV)
`GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/dropped/backlinks`
Public endpoint: no API key required.
Streams a fixed sample of dropped domains with backlinks. No API key and no date are needed, so it is the quickest way to check the schema. Rows are streamed as plain uncompressed CSV text, so a parser can start on the first row while the rest is still arriving. Use offset and limit to walk the file in pages.
**Parameters**
| Parameter | In | Required | Type | Default | Description |
|-----------|----|----------|------|---------|-------------|
| `whois` | query | no | boolean | `false` | true streams the full WHOIS record per domain with a CSV header row; false streams only the domain names, one per line and with no header. The cleaned file types exist only in the WHOIS form, so pass true for those. |
| `offset` | query | no | integer (int64) | | Data rows to skip from the start of the file. The header row is never counted. Rows are skipped by reading forward, so a large offset costs more than a small one. |
| `limit` | query | no | integer (int64) | | Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on its own. |
**Usage**
Python
```python
"""Stream a sample of dropped domains with backlinks (CSV): GET https://files.whoisfreaks.com/v3.3/stream/domainer/sample/dropped/backlinks
Run it (public endpoint, no API key needed):
python StreamDomainerDroppedBacklinksSample.py
"""
import whoisfreaks
config = whoisfreaks.Configuration()
# Public endpoint: no API key needed.
with whoisfreaks.ApiClient(config) as client:
api = whoisfreaks.DatabasesStreamingApi(client)
# stream_domainer_dropped_backlinks_sample parameters:
# whois (bool, optional, keyword): true streams the full WHOIS record per domain with a CSV header row; false st...; default False
# offset (int, optional, keyword): Data rows to skip from the start of the file. The header row is never counted...
# limit (int, optional, keyword): Maximum data rows to return. Omit for the whole file. limit=0 returns the hea...
csv_text = api.stream_domainer_dropped_backlinks_sample() # plain CSV text, already decompressed
print(csv_text)
```
TypeScript
```typescript
// 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 {
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;
});
```
</details>
Go
```go
// Runnable example: Stream a sample of dropped domains with backlinks (CSV) (GET /v3.3/stream/domainer/sample/dropped/backlinks)
// Run it from the Getting Started module: save it as main.go, then `go run .`
// Parameters for streamDomainerDroppedBacklinksSample (GET /v3.3/stream/domainer/sample/dropped/backlinks):
// - whois (boolean, optional): true streams the full WHOIS record per domain with a CSV header row; false streams only...
// - offset (integer, optional): Data rows to skip from the start of the file. The header row is never counted. Rows are...
// - limit (integer, optional): Maximum data rows to return. Omit for the whole file. limit=0 returns the header row on...
package main
import (
"context"
"encoding/json"
"fmt"
"log"
whoisfreaks "github.com/WhoisFreaks/whoisfreaks-go"
)
func main() {
// Public endpoint: no API key needed.
ctx := context.Background()
client := whoisfreaks.NewAPIClient(whoisfreaks.NewConfiguration())
result, _, err := client.DatabasesStreamingAPI.StreamDomainerDroppedBacklinksSample(ctx).Execute()
if err != nil {
log.Fatal(err)
}
out, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(out))
}
```
---