# Domain Availability, Expiry, WHOIS, DNS, IP, ASN, 70+ TLD (`datascoutapi/domaindaddy`)

Checks domain availability and expiry dates, retrieves WHOIS & RDAP data, analyzes DNS records (A, MX, NS, TXT), provides IP geolocation and ASN details, calculates domain age, and supports batch processing. Supports 70+ TLDs, handles errors gracefully, and delivers clean, structured JSON output.

- **URL**: https://beta-securitybyobscurity.apify.com/datascoutapi/domaindaddy.md
- **Developed by:** [halam](https://beta-securitybyobscurity.apify.com/datascoutapi) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 13 total users, 13 monthly users, 98.8% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.85 / 1,000 lookups

This Actor is paid per result. You are not charged for the Apify platform usage, but only a fixed price for dataset items the Actor outputs.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-result

# README

## DomainDaddy - Ultimate Domain Intelligence Platform

A powerful Apify actor that scrapes comprehensive domain information including WHOIS data, DNS records, IP addresses, ASN information, and more.

### 🚀 Quick Start

**Input**: Provide a domain, list of domains, or URLs\
**Run**: Execute the actor on Apify\
**Output**: Get detailed domain analysis in the dataset

### ✨ Enhanced Features

- **Domain Availability Checking**: Determine if domains are registered or available for purchase
- **Complete WHOIS Data**: Creation date, expiration date, registrar details, name servers
- **Comprehensive DNS Records**: A records, MX records, TXT records, SPF records
- **Advanced IP Analysis**: IP addresses, ASN numbers, ASN country, ASN description
- **Registrar Intelligence**: Accredited registrar details from ICANN with country information
- **Email Extraction**: Contact emails from WHOIS data
- **Domain Age Calculation**: Precise domain age with years and days breakdown
- **Flexible Input Options**: Accepts domains, URLs, or lists of either
- **Robust Error Handling**: Graceful handling of invalid domains with detailed error reporting
- **Batch Processing**: Handle up to 100 domains in a single run
- **Rate Limiting**: Built-in delays to respect DNS and WHOIS server limits

### 🌐 Supported Top-Level Domains

DomainDaddy supports 70+ popular top-level domains including:

.com, .org, .net, .io, .in, .it, .fr, .nl, .pl, .cn, .co, .xyz, .top, .info, .ca, .us, .kr, .online, .me, .app, .site, .mx, .cc, .gov, .tv, .pro, .se, .cloud, .ai, .be, .biz, .tw, .dk, .live, .shop, .fi, .vip, .club, .sk, .no, .kz, .dev, .il, .store, .nz, .tech, .ie, .click, .fun, .rs, .su, .one, .sg, .link, .lt, .space, .win, .life, .si, .mobi, .lol, .gg, .ee, .edu, .hr, .jp, .id

### 📥 Input Schema

The actor accepts domains in various formats:

#### Supported Input Formats:

- google.com
- www.google.com
- https://google.com
- https://www.google.com
- http://subdomain.google.com

The actor automatically normalizes these formats to extract the domain name.

#### Input Parameters

| Parameter | Type | Description | Required |
|-----------|------|-------------|----------|
| domains | array | List of domain names or URLs to analyze | Yes |

#### Input Examples:

##### Single Domain

```json
{
  "domains": ["example.com"]
}
```

##### Multiple Domains

```json
{
  "domains": [
    "example.com",
    "google.com",
    "github.com"
  ]
}
```

##### Mixed Formats

```json
{
  "domains": [
    "example.com",
    "https://www.google.com",
    "http://github.com"
  ]
}
```

### 📤 Enhanced Output Format

Each domain processed will generate a result with the following comprehensive structure:

```json
{
  "domain": "example.com",
  "available": false,
  "registrar": "ICANN",
  "registrarCountry": "United States",
  "createdDate": "1995-08-14T04:00:00Z",
  "expiryDate": "2024-08-13T04:00:00Z",
  "updatedDate": "2023-08-14T04:00:00Z",
  "emails": "dns-admin@example.com",
  "dnssec": false,
  "domainAge": {
    "totalDays": 10572,
    "years": 28,
    "remainingDays": 310,
    "formattedAge": "28 years and 310 days"
  },
  "nameServers": ["a.iana-servers.net", "b.iana-servers.net"],
  "dns": {
    "A": ["93.184.216.34"],
    "MX": [
      {
        "exchange": "mail.example.com",
        "priority": 10
      }
    ],
    "NS": ["a.iana-servers.net", "b.iana-servers.net"],
    "TXT": ["v=spf1 -all"]
  },
  "spf": "v=spf1 -all",
  "ipAddresses": "93.184.216.34",
  "ASN": "15133",
  "ASN_Country": "US",
  "ASN_Description": "EDGECAST - EdgeCast Inc.",
  "TXT": "v=spf1 -all",
  "MX": "mail.example.com",
  "MX_IP": "93.184.216.34",
  "MX_ASN": "15133",
  "MX_ASN_Country": "US",
  "MX_ASN_Description": "EDGECAST - EdgeCast Inc.",
  "processed_at": "2024-01-15T10:30:00.000Z",
  "actor_run_id": "abc123def456"
}
```

### ⚠️ Error Handling

If a domain cannot be processed, an error result will be generated:

```json
{
  "domain": "invalid-domain",
  "error": "Error message describing the issue",
  "processed_at": "2024-01-15T10:30:00.000Z",
  "actor_run_id": "abc123def456"
}
```

### 📊 Performance & Limits

- **Memory**: 512MB allocated
- **Timeout**: 5 minutes per run
- **Batch Processing**: Up to 100 domains per request
- **Rate Limiting**: Built-in 1-second delays between domain checks
- **TLD Support**: Works with 70+ popular top-level domains

### 💡 Usage Examples

#### Basic Domain Analysis

```json
{
  "domains": ["example.com"]
}
```

#### Batch Domain Processing

```json
{
  "domains": [
    "example.com",
    "google.com",
    "github.com"
  ]
}
```

### 🔍 Use Cases

- **Domain Portfolio Management**: Analyze and track your domain investments
- **Cybersecurity Research**: Investigate suspicious domains and infrastructure
- **Competitor Analysis**: Research competitor domain registration patterns
- **SEO Analysis**: Factor domain age into SEO strategies
- **Due Diligence**: Verify domain ownership and registration details
- **Brand Protection**: Monitor for trademark infringements
- **Market Research**: Analyze domain registration trends

### 🛠️ Best Practices

1. Start with 1-5 domains to test functionality
2. Use valid domain formats (automatic URL normalization available)
3. Check logs for detailed error information
4. For large batches, consider splitting into multiple runs
5. Leverage the structured output for integration with other tools

### 🆘 Support

For issues or questions:

- Check the Apify platform documentation
- Review the actor logs for detailed error information
- Contact support through the Apify console
- Ensure your input matches the documented schema

### 📄 License

MIT License - This actor is provided as-is for use on the Apify platform.

# Actor input Schema

## `domains` (type: `array`):

List of domain names or URLs to check. Supports various formats: domain.com, www.domain.com, https://domain.com, etc. Supports 70+ TLDs including .com, .org, .net, .io, .ai, .dev, .app, and many more.

## Actor input object example

```json
{
  "domains": [
    "google.com",
    "https://www.github.io",
    "stackoverflow.com",
    "www.reddit.com",
    "https://openai.com",
    "example.org"
  ]
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "google.com",
        "https://www.github.io",
        "stackoverflow.com",
        "www.reddit.com",
        "https://openai.com",
        "example.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascoutapi/domaindaddy").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "domains": [
        "google.com",
        "https://www.github.io",
        "stackoverflow.com",
        "www.reddit.com",
        "https://openai.com",
        "example.org",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datascoutapi/domaindaddy").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "google.com",
    "https://www.github.io",
    "stackoverflow.com",
    "www.reddit.com",
    "https://openai.com",
    "example.org"
  ]
}' |
apify call datascoutapi/domaindaddy --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datascoutapi/domaindaddy",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Domain Availability, Expiry, WHOIS, DNS, IP, ASN, 70+ TLD",
        "description": "Checks domain availability and expiry dates, retrieves WHOIS & RDAP data, analyzes DNS records (A, MX, NS, TXT), provides IP geolocation and ASN details, calculates domain age, and supports batch processing. Supports 70+ TLDs, handles errors gracefully, and delivers clean, structured JSON output.",
        "version": "0.0",
        "x-build-id": "js3xjKSHnWYcVSz32"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascoutapi~domaindaddy/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascoutapi-domaindaddy",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/datascoutapi~domaindaddy/runs": {
            "post": {
                "operationId": "runs-sync-datascoutapi-domaindaddy",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/datascoutapi~domaindaddy/run-sync": {
            "post": {
                "operationId": "run-sync-datascoutapi-domaindaddy",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains to check",
                        "minItems": 1,
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of domain names or URLs to check. Supports various formats: domain.com, www.domain.com, https://domain.com, etc. Supports 70+ TLDs including .com, .org, .net, .io, .ai, .dev, .app, and many more.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
