> For the complete documentation index see https://domscan.net/llms.txt. Markdown versions of every docs page are available by appending .md to the page URL.

Source: https://domscan.net/docs/products/workflow-recipes

# Workflow recipes API

Pre-built API workflows for common domain intelligence tasks. Each recipe combines multiple endpoints to accomplish a specific goal. Use this reference to pick the right endpoint and see exactly what it returns.

[View product page](https://domscan.net/workflow-recipes-api)

## Operations

GET `/v1/recipes/due-diligence` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipeDueDiligence)

GET `/v1/recipes/brand-launch` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipeBrandLaunch)

GET `/v1/recipes/threat-assessment` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipeThreatAssessment)

GET `/v1/recipes/domain-finder` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipeDomainFinder)

GET `/v1/recipes/competitor-intel` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipeCompetitorIntel)

GET `/v1/recipes/portfolio-audit` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipePortfolioAudit)

POST `/v1/recipes/portfolio-audit` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipePortfolioAuditPost)

GET `/v1/recipes/email-deliverability` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipeEmailDeliverability)

GET `/v1/recipes/dns-migration` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipeDnsMigration)

GET `/v1/recipes/infrastructure-discovery` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipeInfrastructureDiscovery)

GET `/v1/recipes/defensive-registration` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipeDefensiveRegistration)

GET `/v1/recipes/phishing-investigation` [View API reference](https://domscan.net/docs/products/workflow-recipes#recipePhishingInvestigation)

## GET `/v1/recipes/due-diligence`

Operation: `recipeDueDiligence`
Credits and authentication: 12
Authentication required

GET /v1/recipes/due-diligence Credits: 12

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domain | string | required |
| include_competitors | boolean Default `false` | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.domain` | string |
| `data.summary` | object |
| `data.summary.recommendation` | string |
| `data.summary.confidence_score` | number |
| `data.summary.key_findings[]` | string[] |
| `data.summary.risk_factors[]` | string[] |
| `data.registration` | object |
| `data.registration.registrar` | string |
| `data.registration.created_date` | string |
| `data.registration.expiry_date` | string |
| `data.registration.updated_date` | string |
| `data.registration.age_years` | number |
| `data.registration.days_until_expiry` | number |
| `data.registration.status[]` | string[] |
| `data.registration.nameservers[]` | string[] |
| `data.registration.dnssec` | boolean |
| `data.registration.privacy_protected` | boolean |
| `data.valuation` | object |
| `data.valuation.estimate_low` | number |
| `data.valuation.estimate_mid` | number |
| `data.valuation.estimate_high` | number |
| `data.valuation.currency` | string |
| `data.valuation.confidence` | number |
| `data.valuation.factors` | object |
| `data.valuation.factors.length` | number |
| `data.valuation.factors.tld` | string |
| `data.valuation.factors.brandability` | number |
| `data.health` | object |
| `data.health.score` | number |
| `data.health.grade` | string |
| `data.health.dns_configured` | boolean |
| `data.health.ssl_valid` | boolean |
| `data.health.email_deliverable` | boolean |
| `data.health.warnings[]` | string[] |
| `data.security` | object |
| `data.security.reputation_score` | number |
| `data.security.reputation_grade` | string |
| `data.security.risk_level` | string |
| `data.security.blacklisted` | boolean |
| `data.security.blacklist_details[]` | array |
| `data.brand_protection` | object |
| `data.brand_protection.typo_score` | number |
| `data.brand_protection.typo_grade` | string |
| `data.brand_protection.variants_registered` | number |
| `data.brand_protection.high_risk_variants` | number |
| `data.pricing` | object |
| `data.pricing.best_price` | number |
| `data.pricing.best_registrar` | string |
| `data.pricing.all_prices[]` | object[] |
| `data.pricing.all_prices[]` | object |
| `data.pricing.all_prices[].registrar` | string |
| `data.pricing.all_prices[].price` | number |
| `data.pricing.all_prices[].currency` | string |
| `data.action_items[]` | object[] |
| `data.action_items[]` | object |
| `data.action_items[].priority` | string |
| `data.action_items[].category` | string |
| `data.action_items[].action` | string |
| `data.action_items[].details` | string |
| `data.action_items[].estimated_impact` | string |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | string[] |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/due-diligence?domain=example.com&include_competitors=false"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/due-diligence?domain=example.com&include_competitors=false", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/due-diligence?domain=example.com&include_competitors=false",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/due-diligence?domain=example.com&include_competitors=false", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/due-diligence?domain=example.com&include_competitors=false")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Example response

```json
{
  "success": true,
  "data": {
    "domain": "example.com",
    "summary": {
      "recommendation": "buy",
      "confidence_score": 88,
      "key_findings": [
        "Established registration history",
        "Clean reputation"
      ],
      "risk_factors": [
        "DNSSEC not enabled"
      ]
    },
    "registration": {
      "registrar": "Example Registrar",
      "created_date": "2019-03-11",
      "expiry_date": "2027-03-11",
      "updated_date": "2026-03-10",
      "age_years": 7,
      "days_until_expiry": 330,
      "status": [
        "active",
        "clientTransferProhibited"
      ],
      "nameservers": [
        "ns1.example.net",
        "ns2.example.net"
      ],
      "dnssec": false,
      "privacy_protected": true
    },
    "valuation": {
      "estimate_low": 1800,
      "estimate_mid": 3500,
      "estimate_high": 5200,
      "currency": "USD",
      "confidence": 0.72,
      "factors": {
        "length": 11,
        "tld": "com",
        "brandability": 0.81
      }
    },
    "health": {
      "score": 84,
      "grade": "A",
      "dns_configured": true,
      "ssl_valid": true,
      "email_deliverable": true,
      "warnings": [
        "DNSSEC not enabled"
      ]
    },
    "security": {
      "reputation_score": 91,
      "reputation_grade": "A",
      "risk_level": "low",
      "blacklisted": false,
      "blacklist_details": []
    },
    "brand_protection": {
      "typo_score": 78,
      "typo_grade": "B",
      "variants_registered": 2,
      "high_risk_variants": 1
    },
    "pricing": {
      "best_price": 9.99,
      "best_registrar": "cloudflare",
      "all_prices": [
        {
          "registrar": "cloudflare",
          "price": 9.99,
          "currency": "USD"
        }
      ]
    },
    "action_items": [
      {
        "priority": "medium",
        "category": "security",
        "action": "Enable DNSSEC",
        "details": "Improve zone integrity for resolvers.",
        "estimated_impact": "Lower spoofing risk"
      }
    ]
  },
  "meta": {
    "recipe_name": "domain-due-diligence",
    "credits_used": 12,
    "credits_saved": 6,
    "duration_ms": 742,
    "components_called": [
      "availability",
      "whois",
      "valuation",
      "health",
      "reputation",
      "typosquatting",
      "pricing"
    ],
    "cached_components": [
      "pricing"
    ],
    "timestamp": "2026-04-15T09:30:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## GET `/v1/recipes/brand-launch`

Operation: `recipeBrandLaunch`
Credits and authentication: 10
Authentication required

GET /v1/recipes/brand-launch Credits: 10

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domain | string | required |
| brand_name | string | optional |
| platforms | string | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.domain` | string |
| `data.brand_name` | string |
| `data.readiness_score` | number |
| `data.status` | string |
| `data.checklist` | object |
| `data.checklist.domain_controlled` | object |
| `data.checklist.domain_controlled.name` | string |
| `data.checklist.domain_controlled.status` | string |
| `data.checklist.domain_controlled.details` | string |
| `data.checklist.ssl_configured` | object |
| `data.checklist.ssl_configured.name` | string |
| `data.checklist.ssl_configured.status` | string |
| `data.checklist.ssl_configured.details` | string |
| `data.checklist.dns_configured` | object |
| `data.checklist.dns_configured.name` | string |
| `data.checklist.dns_configured.status` | string |
| `data.checklist.dns_configured.details` | string |
| `data.checklist.email_auth` | object |
| `data.checklist.email_auth.name` | string |
| `data.checklist.email_auth.status` | string |
| `data.checklist.email_auth.score` | number |
| `data.checklist.email_auth.details` | string |
| `data.checklist.email_auth.action` | string |
| `data.checklist.social_handles` | object |
| `data.checklist.social_handles.name` | string |
| `data.checklist.social_handles.status` | string |
| `data.checklist.social_handles.score` | number |
| `data.checklist.social_handles.details` | string |
| `data.checklist.brand_protection` | object |
| `data.checklist.brand_protection.name` | string |
| `data.checklist.brand_protection.status` | string |
| `data.checklist.brand_protection.score` | number |
| `data.checklist.brand_protection.details` | string |
| `data.checklist.reputation_clean` | object |
| `data.checklist.reputation_clean.name` | string |
| `data.checklist.reputation_clean.status` | string |
| `data.checklist.reputation_clean.details` | string |
| `data.checklist.brand_quality` | object |
| `data.checklist.brand_quality.name` | string |
| `data.checklist.brand_quality.status` | string |
| `data.checklist.brand_quality.score` | number |
| `data.checklist.brand_quality.details` | string |
| `data.social_availability[]` | object[] |
| `data.social_availability[]` | object |
| `data.social_availability[].platform` | string |
| `data.social_availability[].available` | boolean |
| `data.social_availability[].url` | string |
| `data.typo_threats` | object |
| `data.typo_threats.total_variants` | number |
| `data.typo_threats.registered_threats` | number |
| `data.typo_threats.high_risk_count` | number |
| `data.brand_score` | object |
| `data.brand_score.overall` | number |
| `data.brand_score.pronounceability` | number |
| `data.brand_score.memorability` | number |
| `data.brand_score.spelling_ease` | number |
| `data.action_items[]` | object[] |
| `data.action_items[]` | object |
| `data.action_items[].priority` | string |
| `data.action_items[].category` | string |
| `data.action_items[].action` | string |
| `data.action_items[].details` | string |
| `data.action_items[].estimated_impact` | string |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | array |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/brand-launch?domain=example.com&brand_name=Example&platforms=github%2Ctwitter"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/brand-launch?domain=example.com&brand_name=Example&platforms=github%2Ctwitter", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/brand-launch?domain=example.com&brand_name=Example&platforms=github%2Ctwitter",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/brand-launch?domain=example.com&brand_name=Example&platforms=github%2Ctwitter", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/brand-launch?domain=example.com&brand_name=Example&platforms=github%2Ctwitter")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Example response

```json
{
  "success": true,
  "data": {
    "domain": "launchbrand.com",
    "brand_name": "Launch Brand",
    "readiness_score": 82,
    "status": "ready",
    "checklist": {
      "domain_controlled": {
        "name": "Domain Ownership",
        "status": "pass",
        "details": "Domain is registered"
      },
      "ssl_configured": {
        "name": "SSL Certificate",
        "status": "pass",
        "details": "HTTPS is working"
      },
      "dns_configured": {
        "name": "DNS Configuration",
        "status": "pass",
        "details": "DNS records configured"
      },
      "email_auth": {
        "name": "Email Authentication",
        "status": "warning",
        "score": 66,
        "details": "Missing: DMARC",
        "action": "Configure DMARC"
      },
      "social_handles": {
        "name": "Social Handles",
        "status": "warning",
        "score": 50,
        "details": "2 of 4 handles available"
      },
      "brand_protection": {
        "name": "Brand Protection",
        "status": "warning",
        "score": 71,
        "details": "1 high-risk typo variant available"
      },
      "reputation_clean": {
        "name": "Reputation",
        "status": "pass",
        "details": "Clean reputation"
      },
      "brand_quality": {
        "name": "Brand Quality",
        "status": "pass",
        "score": 84,
        "details": "Strong memorability and spelling ease"
      }
    },
    "social_availability": [
      {
        "platform": "github",
        "available": true,
        "url": "https://github.com/launchbrand"
      },
      {
        "platform": "twitter",
        "available": false
      }
    ],
    "typo_threats": {
      "total_variants": 48,
      "registered_threats": 2,
      "high_risk_count": 1
    },
    "brand_score": {
      "overall": 84,
      "pronounceability": 80,
      "memorability": 86,
      "spelling_ease": 88
    },
    "action_items": [
      {
        "priority": "high",
        "category": "email",
        "action": "Configure DMARC",
        "details": "Complete the authentication trio before launch.",
        "estimated_impact": "Higher inbox placement"
      }
    ]
  },
  "meta": {
    "recipe_name": "brand-launch-readiness",
    "credits_used": 10,
    "credits_saved": 4,
    "duration_ms": 581,
    "components_called": [
      "availability",
      "health",
      "dns_security",
      "reputation",
      "typosquatting",
      "scoring",
      "social"
    ],
    "cached_components": [],
    "timestamp": "2026-04-15T09:42:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## GET `/v1/recipes/threat-assessment`

Operation: `recipeThreatAssessment`
Credits and authentication: 18
Authentication required

GET /v1/recipes/threat-assessment Credits: 18

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domain | string | required |
| analyze_threats | boolean Default `true` | optional |
| max_threats | integer Default `10` | optional |
| include_evidence | boolean Default `true` | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.domain` | string |
| `data.summary` | object |
| `data.summary.risk_level` | string |
| `data.summary.overall_score` | number |
| `data.summary.total_variants_generated` | number |
| `data.summary.variants_registered` | number |
| `data.summary.active_threats` | number |
| `data.summary.suspicious_activity` | number |
| `data.protection_score` | object |
| `data.protection_score.score` | number |
| `data.protection_score.grade` | string |
| `data.protection_score.vulnerabilities[]` | object[] |
| `data.protection_score.vulnerabilities[]` | object |
| `data.protection_score.vulnerabilities[].category` | string |
| `data.protection_score.vulnerabilities[].count` | number |
| `data.protection_score.vulnerabilities[].risk` | string |
| `data.protection_score.vulnerabilities[].description` | string |
| `data.threats[]` | object[] |
| `data.threats[]` | object |
| `data.threats[].domain` | string |
| `data.threats[].threat_type` | string |
| `data.threats[].risk_level` | string |
| `data.threats[].registered` | boolean |
| `data.threats[].registration` | object |
| `data.threats[].registration.registrar` | string |
| `data.threats[].registration.created_date` | string |
| `data.threats[].registration.privacy_protected` | boolean |
| `data.threats[].infrastructure` | object |
| `data.threats[].infrastructure.ip` | string |
| `data.threats[].infrastructure.hosting_provider` | string |
| `data.threats[].infrastructure.country` | string |
| `data.threats[].indicators` | object |
| `data.threats[].indicators.has_mx_records` | boolean |
| `data.threats[].indicators.has_website` | boolean |
| `data.threats[].indicators.ssl_valid` | boolean |
| `data.threats[].indicators.reputation_flags[]` | string[] |
| `data.threats[].recommendation` | string |
| `data.recommendations[]` | string[] |
| `data.action_items[]` | object[] |
| `data.action_items[]` | object |
| `data.action_items[].priority` | string |
| `data.action_items[].category` | string |
| `data.action_items[].action` | string |
| `data.action_items[].details` | string |
| `data.action_items[].estimated_impact` | string |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | string[] |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/threat-assessment?domain=example.com&analyze_threats=true&max_threats=10&include_evidence=true"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/threat-assessment?domain=example.com&analyze_threats=true&max_threats=10&include_evidence=true", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/threat-assessment?domain=example.com&analyze_threats=true&max_threats=10&include_evidence=true",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/threat-assessment?domain=example.com&analyze_threats=true&max_threats=10&include_evidence=true", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/threat-assessment?domain=example.com&analyze_threats=true&max_threats=10&include_evidence=true")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Example response

```json
{
  "success": true,
  "data": {
    "domain": "brand.com",
    "summary": {
      "risk_level": "high",
      "overall_score": 61,
      "total_variants_generated": 120,
      "variants_registered": 14,
      "active_threats": 3,
      "suspicious_activity": 2
    },
    "protection_score": {
      "score": 73,
      "grade": "B",
      "vulnerabilities": [
        {
          "category": "homoglyph",
          "count": 3,
          "risk": "high",
          "description": "Lookalike Unicode variants are registered."
        }
      ]
    },
    "threats": [
      {
        "domain": "brancd.com",
        "threat_type": "typosquatting",
        "risk_level": "high",
        "registered": true,
        "registration": {
          "registrar": "Example Registrar",
          "created_date": "2026-01-10",
          "privacy_protected": true
        },
        "infrastructure": {
          "ip": "198.51.100.21",
          "hosting_provider": "Example Hosting",
          "country": "US"
        },
        "indicators": {
          "has_mx_records": true,
          "has_website": true,
          "ssl_valid": false,
          "reputation_flags": [
            "recent_registration",
            "parked"
          ]
        },
        "recommendation": "Investigate hosting and submit abuse report."
      }
    ],
    "recommendations": [
      "Monitor newly registered typo variants.",
      "Escalate active lookalike websites to brand protection."
    ],
    "action_items": [
      {
        "priority": "critical",
        "category": "brand-protection",
        "action": "Investigate high-risk typo domains",
        "details": "Three active websites are impersonating the brand.",
        "estimated_impact": "Reduce phishing exposure"
      }
    ]
  },
  "meta": {
    "recipe_name": "threat-assessment",
    "credits_used": 18,
    "credits_saved": 22,
    "duration_ms": 934,
    "components_called": [
      "typosquatting",
      "availability",
      "whois",
      "health",
      "reputation"
    ],
    "cached_components": [
      "availability"
    ],
    "timestamp": "2026-04-15T10:02:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## GET `/v1/recipes/domain-finder`

Operation: `recipeDomainFinder`
Credits and authentication: 12
Authentication required

GET /v1/recipes/domain-finder Credits: 12

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| keywords | string | required |
| tlds | string | optional |
| style | string Allowed values `brandable`, `keyword-rich`, `short` | optional |
| max_length | integer | optional |
| language | string Allowed values `en`, `zh`, `es`, `ja`, `de`, `fr`, `pt`, `it`, `ko`, `ru`, `ar`, `hi`, `bn`, `id`, `ms`, `th`, `vi`, `tr`, `pl`, `nl`, `sv`, `da`, `no`, `fi`, `el`, `cs`, `hu`, `ro`, `uk`, `he` Default `en` | optional |
| limit | integer Default `20` | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.results[]` | object[] |
| `data.results[]` | object |
| `data.results[].domain` | string |
| `data.results[].available` | boolean |
| `data.results[].brand_score` | number |
| `data.results[].value_estimate` | object |
| `data.results[].value_estimate.low` | number |
| `data.results[].value_estimate.mid` | number |
| `data.results[].value_estimate.high` | number |
| `data.results[].registration_price` | number |
| `data.results[].best_registrar` | string |
| `data.results[].social_availability` | object |
| `data.results[].social_availability.github` | boolean |
| `data.results[].social_availability.twitter` | boolean |
| `data.results[].recommendation_score` | number |
| `data.results[].notes[]` | string[] |
| `data.filters_applied` | object |
| `data.filters_applied.tlds[]` | string[] |
| `data.filters_applied.style` | string |
| `data.filters_applied.max_length` | number |
| `data.alternatives_considered` | number |
| `data.search_criteria` | object |
| `data.search_criteria.keywords[]` | string[] |
| `data.search_criteria.tlds[]` | string[] |
| `data.search_criteria.style` | string |
| `data.search_criteria.max_length` | number |
| `data.search_criteria.budget` | object |
| `data.search_criteria.budget.max` | number |
| `data.search_criteria.budget.currency` | string |
| `data.search_criteria.require_social[]` | string[] |
| `data.search_criteria.limit` | number |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | string[] |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/domain-finder?keywords=startup%2Cbrand&tlds=com%2Cio&style=brandable&max_length=15&language=en&limit=10"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/domain-finder?keywords=startup%2Cbrand&tlds=com%2Cio&style=brandable&max_length=15&language=en&limit=10", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/domain-finder?keywords=startup%2Cbrand&tlds=com%2Cio&style=brandable&max_length=15&language=en&limit=10",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/domain-finder?keywords=startup%2Cbrand&tlds=com%2Cio&style=brandable&max_length=15&language=en&limit=10", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/domain-finder?keywords=startup%2Cbrand&tlds=com%2Cio&style=brandable&max_length=15&language=en&limit=10")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Example response

```json
{
  "success": true,
  "data": {
    "results": [
      {
        "domain": "launchgrid.com",
        "available": true,
        "brand_score": 86,
        "value_estimate": {
          "low": 400,
          "mid": 1200,
          "high": 2800
        },
        "registration_price": 10.99,
        "best_registrar": "porkbun",
        "social_availability": {
          "github": true,
          "twitter": false
        },
        "recommendation_score": 92,
        "notes": [
          "Style: brandable",
          "Within budget"
        ]
      }
    ],
    "filters_applied": {
      "tlds": [
        "com",
        "io"
      ],
      "style": "brandable",
      "max_length": 12
    },
    "alternatives_considered": 42,
    "search_criteria": {
      "keywords": [
        "launch",
        "grid"
      ],
      "tlds": [
        "com",
        "io"
      ],
      "style": "brandable",
      "max_length": 12,
      "budget": {
        "max": 20,
        "currency": "USD"
      },
      "require_social": [
        "github",
        "twitter"
      ],
      "limit": 10
    }
  },
  "meta": {
    "recipe_name": "domain-finder",
    "credits_used": 12,
    "credits_saved": 13,
    "duration_ms": 611,
    "components_called": [
      "suggest",
      "availability",
      "valuation",
      "scoring",
      "social",
      "pricing"
    ],
    "cached_components": [
      "pricing"
    ],
    "timestamp": "2026-04-15T10:11:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## GET `/v1/recipes/competitor-intel`

Operation: `recipeCompetitorIntel`
Credits and authentication: 15
Authentication required

GET /v1/recipes/competitor-intel Credits: 15

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domain | string | required |
| discover_subdomains | boolean Default `true` | optional |
| analyze_infrastructure | boolean Default `true` | optional |
| analyze_email | boolean Default `true` | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.domain` | string |
| `data.company` | object |
| `data.company.name` | string |
| `data.company.industry` | string |
| `data.company.description` | string |
| `data.infrastructure` | object |
| `data.infrastructure.hosting` | string |
| `data.infrastructure.cdn` | string |
| `data.infrastructure.dns_provider` | string |
| `data.infrastructure.email_provider` | string |
| `data.infrastructure.ip_addresses[]` | string[] |
| `data.technology` | object |
| `data.technology.cms` | null |
| `data.technology.frameworks[]` | string[] |
| `data.technology.analytics[]` | string[] |
| `data.technology.marketing[]` | string[] |
| `data.technology.all_detected[]` | string[] |
| `data.digital_footprint` | object |
| `data.digital_footprint.subdomains_found[]` | string[] |
| `data.digital_footprint.ssl_certificates` | number |
| `data.digital_footprint.email_security_grade` | string |
| `data.insights[]` | string[] |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | string[] |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/competitor-intel?domain=example.com&discover_subdomains=true&analyze_infrastructure=true&analyze_email=true"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/competitor-intel?domain=example.com&discover_subdomains=true&analyze_infrastructure=true&analyze_email=true", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/competitor-intel?domain=example.com&discover_subdomains=true&analyze_infrastructure=true&analyze_email=true",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/competitor-intel?domain=example.com&discover_subdomains=true&analyze_infrastructure=true&analyze_email=true", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/competitor-intel?domain=example.com&discover_subdomains=true&analyze_infrastructure=true&analyze_email=true")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Example response

```json
{
  "success": true,
  "data": {
    "domain": "competitor.com",
    "company": {
      "name": "Competitor Inc.",
      "industry": "SaaS",
      "description": "B2B workflow platform"
    },
    "infrastructure": {
      "hosting": "Vercel",
      "cdn": "Cloudflare",
      "dns_provider": "Cloudflare",
      "email_provider": "Google Workspace",
      "ip_addresses": [
        "198.51.100.11",
        "198.51.100.12"
      ]
    },
    "technology": {
      "cms": null,
      "frameworks": [
        "Next.js"
      ],
      "analytics": [
        "Google Analytics"
      ],
      "marketing": [
        "HubSpot"
      ],
      "all_detected": [
        "Cloudflare",
        "Next.js",
        "HubSpot",
        "Google Analytics"
      ]
    },
    "digital_footprint": {
      "subdomains_found": [
        "www",
        "app",
        "api",
        "status"
      ],
      "ssl_certificates": 5,
      "email_security_grade": "A"
    },
    "insights": [
      "Cloudflare is fronting the main web stack.",
      "Separate status infrastructure is publicly exposed."
    ]
  },
  "meta": {
    "recipe_name": "competitor-intelligence",
    "credits_used": 15,
    "credits_saved": 5,
    "duration_ms": 915,
    "components_called": [
      "whois",
      "dns",
      "dns-security",
      "tech",
      "subdomains",
      "certificates",
      "ip"
    ],
    "cached_components": [
      "dns"
    ],
    "timestamp": "2026-04-15T10:22:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## GET `/v1/recipes/portfolio-audit`

Operation: `recipePortfolioAudit`
Credits and authentication: 25
Authentication required

GET /v1/recipes/portfolio-audit Credits: 25

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domains | string | required |
| include_valuation | boolean Default `true` | optional |
| include_health | boolean Default `true` | optional |
| include_pricing | boolean Default `true` | optional |
| alert_expiring_days | integer Default `90` | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.summary` | object |
| `data.summary.total_domains` | number |
| `data.summary.total_value_low` | number |
| `data.summary.total_value_high` | number |
| `data.summary.average_health_score` | number |
| `data.summary.expiring_soon` | number |
| `data.summary.renewal_cost_annual` | number |
| `data.alerts[]` | object[] |
| `data.alerts[]` | object |
| `data.alerts[].domain` | string |
| `data.alerts[].type` | string |
| `data.alerts[].severity` | string |
| `data.alerts[].message` | string |
| `data.alerts[].action` | string |
| `data.optimization` | object |
| `data.optimization.registrar_consolidation` | object |
| `data.optimization.registrar_consolidation.current_registrars` | number |
| `data.optimization.registrar_consolidation.recommendation` | string |
| `data.optimization.registrar_consolidation.potential_savings` | number |
| `data.optimization.underperforming[]` | string[] |
| `data.optimization.top_valuable[]` | string[] |
| `data.domains[]` | object[] |
| `data.domains[]` | object |
| `data.domains[].domain` | string |
| `data.domains[].status` | string |
| `data.domains[].value_estimate` | object |
| `data.domains[].value_estimate.low` | number |
| `data.domains[].value_estimate.mid` | number |
| `data.domains[].value_estimate.high` | number |
| `data.domains[].health_score` | number |
| `data.domains[].health_grade` | string |
| `data.domains[].expiry_date` | string |
| `data.domains[].days_until_expiry` | number |
| `data.domains[].renewal_price` | number |
| `data.domains[].issues[]` | array |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | string[] |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/portfolio-audit?domains=example.com%2Cexample.net&include_valuation=true&include_health=true&include_pricing=true&alert_expiring_days=90"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/portfolio-audit?domains=example.com%2Cexample.net&include_valuation=true&include_health=true&include_pricing=true&alert_expiring_days=90", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/portfolio-audit?domains=example.com%2Cexample.net&include_valuation=true&include_health=true&include_pricing=true&alert_expiring_days=90",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/portfolio-audit?domains=example.com%2Cexample.net&include_valuation=true&include_health=true&include_pricing=true&alert_expiring_days=90", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/portfolio-audit?domains=example.com%2Cexample.net&include_valuation=true&include_health=true&include_pricing=true&alert_expiring_days=90")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Example response

```json
{
  "success": true,
  "data": {
    "summary": {
      "total_domains": 3,
      "total_value_low": 3200,
      "total_value_high": 12400,
      "average_health_score": 78,
      "expiring_soon": 1,
      "renewal_cost_annual": 98.4
    },
    "alerts": [
      {
        "domain": "brandold.com",
        "type": "expiration",
        "severity": "high",
        "message": "Expires in 12 days.",
        "action": "Renew immediately"
      }
    ],
    "optimization": {
      "registrar_consolidation": {
        "current_registrars": 3,
        "recommendation": "Move long-tail domains to a single low-cost registrar.",
        "potential_savings": 48
      },
      "underperforming": [
        "brandold.com"
      ],
      "top_valuable": [
        "brand.com"
      ]
    },
    "domains": [
      {
        "domain": "brand.com",
        "status": "owned",
        "value_estimate": {
          "low": 2500,
          "mid": 4600,
          "high": 9000
        },
        "health_score": 92,
        "health_grade": "A",
        "expiry_date": "2027-02-01",
        "days_until_expiry": 292,
        "renewal_price": 12.99,
        "issues": []
      }
    ]
  },
  "meta": {
    "recipe_name": "portfolio-audit",
    "credits_used": 25,
    "credits_saved": 275,
    "duration_ms": 1298,
    "components_called": [
      "availability",
      "whois",
      "valuation",
      "health",
      "pricing"
    ],
    "cached_components": [
      "valuation"
    ],
    "timestamp": "2026-04-15T10:31:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## POST `/v1/recipes/portfolio-audit`

Operation: `recipePortfolioAuditPost`
Credits and authentication: 25
Authentication required

POST /v1/recipes/portfolio-audit Credits: 25

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| dry_run | string Allowed values `true` | optional |

#### Body parameters

| Parameter | Type | required |
| --- | --- | --- |
| domains | string[] | required |
| include_valuation | boolean Default `true` | optional |
| include_health | boolean Default `true` | optional |
| include_pricing | boolean Default `true` | optional |
| alert_expiring_days | integer Default `90` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.summary` | object |
| `data.summary.total_domains` | number |
| `data.summary.total_value_low` | number |
| `data.summary.total_value_high` | number |
| `data.summary.average_health_score` | number |
| `data.summary.expiring_soon` | number |
| `data.summary.renewal_cost_annual` | number |
| `data.alerts[]` | object[] |
| `data.alerts[]` | object |
| `data.alerts[].domain` | string |
| `data.alerts[].type` | string |
| `data.alerts[].severity` | string |
| `data.alerts[].message` | string |
| `data.alerts[].action` | string |
| `data.optimization` | object |
| `data.optimization.registrar_consolidation` | object |
| `data.optimization.registrar_consolidation.current_registrars` | number |
| `data.optimization.registrar_consolidation.recommendation` | string |
| `data.optimization.registrar_consolidation.potential_savings` | number |
| `data.optimization.underperforming[]` | string[] |
| `data.optimization.top_valuable[]` | string[] |
| `data.domains[]` | object[] |
| `data.domains[]` | object |
| `data.domains[].domain` | string |
| `data.domains[].status` | string |
| `data.domains[].value_estimate` | object |
| `data.domains[].value_estimate.low` | number |
| `data.domains[].value_estimate.mid` | number |
| `data.domains[].value_estimate.high` | number |
| `data.domains[].health_score` | number |
| `data.domains[].health_grade` | string |
| `data.domains[].expiry_date` | string |
| `data.domains[].days_until_expiry` | number |
| `data.domains[].renewal_price` | number |
| `data.domains[].issues[]` | array |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | string[] |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -X POST "https://domscan.net/v1/recipes/portfolio-audit" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "domains": [
    "example.com",
    "example.org",
    "example.net"
  ],
  "include_valuation": true,
  "include_health": true,
  "include_pricing": false,
  "alert_expiring_days": 60
}'
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/portfolio-audit", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "domains": [
      "example.com",
      "example.org",
      "example.net"
    ],
    "include_valuation": true,
    "include_health": true,
    "include_pricing": false,
    "alert_expiring_days": 60
  }),
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.post(
    "https://domscan.net/v1/recipes/portfolio-audit",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "domains": [
            "example.com",
            "example.org",
            "example.net",
        ],
        "include_valuation": True,
        "include_health": True,
        "include_pricing": False,
        "alert_expiring_days": 60,
    },
)
print(response.json())
```

```go
package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{
	  "domains": [
	    "example.com",
	    "example.org",
	    "example.net"
	  ],
	  "include_valuation": true,
	  "include_health": true,
	  "include_pricing": false,
	  "alert_expiring_days": 60
	}`)
	req, err := http.NewRequest(http.MethodPost, "https://domscan.net/v1/recipes/portfolio-audit", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/portfolio-audit")
request = Net::HTTP::Post.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({
  "domains" => [
    "example.com",
    "example.org",
    "example.net"
  ],
  "include_valuation" => true,
  "include_health" => true,
  "include_pricing" => false,
  "alert_expiring_days" => 60
})

#### Example response

```json
{
  "success": true,
  "data": {
    "summary": {
      "total_domains": 3,
      "total_value_low": 3200,
      "total_value_high": 12400,
      "average_health_score": 78,
      "expiring_soon": 1,
      "renewal_cost_annual": 98.4
    },
    "alerts": [
      {
        "domain": "brandold.com",
        "type": "expiration",
        "severity": "high",
        "message": "Expires in 12 days.",
        "action": "Renew immediately"
      }
    ],
    "optimization": {
      "registrar_consolidation": {
        "current_registrars": 3,
        "recommendation": "Move long-tail domains to a single low-cost registrar.",
        "potential_savings": 48
      },
      "underperforming": [
        "brandold.com"
      ],
      "top_valuable": [
        "brand.com"
      ]
    },
    "domains": [
      {
        "domain": "brand.com",
        "status": "owned",
        "value_estimate": {
          "low": 2500,
          "mid": 4600,
          "high": 9000
        },
        "health_score": 92,
        "health_grade": "A",
        "expiry_date": "2027-02-01",
        "days_until_expiry": 292,
        "renewal_price": 12.99,
        "issues": []
      }
    ]
  },
  "meta": {
    "recipe_name": "portfolio-audit",
    "credits_used": 25,
    "credits_saved": 275,
    "duration_ms": 1298,
    "components_called": [
      "availability",
      "whois",
      "valuation",
      "health",
      "pricing"
    ],
    "cached_components": [
      "valuation"
    ],
    "timestamp": "2026-04-15T10:31:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `409` HTTP 409
- `422` HTTP 422
- `429` Too Many Requests

## GET `/v1/recipes/email-deliverability`

Operation: `recipeEmailDeliverability`
Credits and authentication: 10
Authentication required

GET /v1/recipes/email-deliverability Credits: 10

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domain | string | required |
| dkim_selectors | string | optional |
| check_blacklists | boolean Default `true` | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.domain` | string |
| `data.grade` | string |
| `data.score` | number |
| `data.authentication` | object |
| `data.authentication.spf` | object |
| `data.authentication.spf.status` | string |
| `data.authentication.spf.record` | string |
| `data.authentication.spf.issues[]` | array |
| `data.authentication.dkim` | object |
| `data.authentication.dkim.status` | string |
| `data.authentication.dkim.record` | string |
| `data.authentication.dkim.issues[]` | string[] |
| `data.authentication.dkim.recommendation` | string |
| `data.authentication.dkim.selectors_found[]` | string[] |
| `data.authentication.dmarc` | object |
| `data.authentication.dmarc.status` | string |
| `data.authentication.dmarc.record` | string |
| `data.authentication.dmarc.issues[]` | string[] |
| `data.authentication.dmarc.recommendation` | string |
| `data.authentication.dmarc.policy` | string |
| `data.infrastructure` | object |
| `data.infrastructure.mx_servers[]` | string[] |
| `data.infrastructure.ip_reputation` | string |
| `data.infrastructure.shared_ip_risk` | string |
| `data.blacklist_status` | object |
| `data.blacklist_status.status` | string |
| `data.blacklist_status.listed_on[]` | array |
| `data.blacklist_status.unknown_on[]` | array |
| `data.blacklist_status.clean` | boolean |
| `data.action_items[]` | object[] |
| `data.action_items[]` | object |
| `data.action_items[].priority` | string |
| `data.action_items[].category` | string |
| `data.action_items[].action` | string |
| `data.action_items[].details` | string |
| `data.action_items[].estimated_impact` | string |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | array |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/email-deliverability?domain=example.com&dkim_selectors=default%2Cgoogle&check_blacklists=true"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/email-deliverability?domain=example.com&dkim_selectors=default%2Cgoogle&check_blacklists=true", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/email-deliverability?domain=example.com&dkim_selectors=default%2Cgoogle&check_blacklists=true",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/email-deliverability?domain=example.com&dkim_selectors=default%2Cgoogle&check_blacklists=true", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/email-deliverability?domain=example.com&dkim_selectors=default%2Cgoogle&check_blacklists=true")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Example response

```json
{
  "success": true,
  "data": {
    "domain": "example.com",
    "grade": "B",
    "score": 74,
    "authentication": {
      "spf": {
        "status": "pass",
        "record": "v=spf1 include:_spf.google.com ~all",
        "issues": []
      },
      "dkim": {
        "status": "warning",
        "record": "selector discovery incomplete",
        "issues": [
          "Only one selector found"
        ],
        "recommendation": "Add dedicated selectors for all providers",
        "selectors_found": [
          "google"
        ]
      },
      "dmarc": {
        "status": "warning",
        "record": "v=DMARC1; p=none; rua=mailto:dmarc@example.com",
        "issues": [
          "Policy is monitoring-only"
        ],
        "recommendation": "Move to quarantine or reject",
        "policy": "none"
      }
    },
    "infrastructure": {
      "mx_servers": [
        "aspmx.l.google.com"
      ],
      "ip_reputation": "low",
      "shared_ip_risk": "medium"
    },
    "blacklist_status": {
      "status": "clean",
      "listed_on": [],
      "unknown_on": [],
      "clean": true
    },
    "action_items": [
      {
        "priority": "high",
        "category": "email",
        "action": "Strengthen DMARC policy",
        "details": "Current DMARC policy is set to none.",
        "estimated_impact": "Better spoofing protection"
      }
    ]
  },
  "meta": {
    "recipe_name": "email-deliverability",
    "credits_used": 10,
    "credits_saved": 5,
    "duration_ms": 662,
    "components_called": [
      "dns-security",
      "dnsbl",
      "mx-analysis"
    ],
    "cached_components": [],
    "timestamp": "2026-04-15T10:43:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## GET `/v1/recipes/dns-migration`

Operation: `recipeDnsMigration`
Credits and authentication: 7
Authentication required

GET /v1/recipes/dns-migration Credits: 7

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domain | string | required |
| target_nameservers | string | optional |
| critical_records | string | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.domain` | string |
| `data.status` | string |
| `data.current_configuration` | object |
| `data.current_configuration.nameservers[]` | string[] |
| `data.current_configuration.records` | object |
| `data.current_configuration.records.A[]` | string[] |
| `data.current_configuration.records.MX[]` | string[] |
| `data.current_configuration.records.TXT[]` | string[] |
| `data.current_configuration.email_auth` | object |
| `data.current_configuration.email_auth.spf` | string |
| `data.current_configuration.email_auth.dkim_selectors[]` | string[] |
| `data.current_configuration.email_auth.dmarc` | string |
| `data.migration_checklist[]` | object[] |
| `data.migration_checklist[]` | object |
| `data.migration_checklist[].record_type` | string |
| `data.migration_checklist[].current_value` | string |
| `data.migration_checklist[].action` | string |
| `data.migration_checklist[].critical` | boolean |
| `data.migration_checklist[].ttl` | number |
| `data.warnings[]` | object[] |
| `data.warnings[]` | object |
| `data.warnings[].type` | string |
| `data.warnings[].message` | string |
| `data.warnings[].records[]` | string[] |
| `data.estimated_propagation` | string |
| `data.rollback_plan` | object |
| `data.rollback_plan.keep_old_records_until` | string |
| `data.rollback_plan.revert_steps[]` | string[] |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | string[] |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/dns-migration?domain=example.com&target_nameservers=ns1.newdns.net%2Cns2.newdns.net&critical_records=A%2CAAAA%2CMX"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/dns-migration?domain=example.com&target_nameservers=ns1.newdns.net%2Cns2.newdns.net&critical_records=A%2CAAAA%2CMX", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/dns-migration?domain=example.com&target_nameservers=ns1.newdns.net%2Cns2.newdns.net&critical_records=A%2CAAAA%2CMX",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/dns-migration?domain=example.com&target_nameservers=ns1.newdns.net%2Cns2.newdns.net&critical_records=A%2CAAAA%2CMX", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/dns-migration?domain=example.com&target_nameservers=ns1.newdns.net%2Cns2.newdns.net&critical_records=A%2CAAAA%2CMX")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Example response

```json
{
  "success": true,
  "data": {
    "domain": "example.com",
    "status": "ready",
    "current_configuration": {
      "nameservers": [
        "ns1.current-dns.net",
        "ns2.current-dns.net"
      ],
      "records": {
        "A": [
          "198.51.100.8"
        ],
        "MX": [
          "10 mail.example.com"
        ],
        "TXT": [
          "v=spf1 include:_spf.google.com ~all"
        ]
      },
      "email_auth": {
        "spf": "v=spf1 include:_spf.google.com ~all",
        "dkim_selectors": [
          "google",
          "mail"
        ],
        "dmarc": "v=DMARC1; p=quarantine"
      }
    },
    "migration_checklist": [
      {
        "record_type": "MX",
        "current_value": "10 mail.example.com",
        "action": "migrate",
        "critical": true,
        "ttl": 3600
      }
    ],
    "warnings": [
      {
        "type": "ttl",
        "message": "High TTL values will slow cutover.",
        "records": [
          "A",
          "MX"
        ]
      }
    ],
    "estimated_propagation": "4-8 hours",
    "rollback_plan": {
      "keep_old_records_until": "48-72 hours after migration",
      "revert_steps": [
        "Keep screenshots of the current zone",
        "Restore old nameservers at the registrar if traffic fails"
      ]
    }
  },
  "meta": {
    "recipe_name": "dns-migration",
    "credits_used": 7,
    "credits_saved": 5,
    "duration_ms": 734,
    "components_called": [
      "dns",
      "dns-security",
      "ttl-analysis"
    ],
    "cached_components": [
      "dns"
    ],
    "timestamp": "2026-04-15T10:54:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## GET `/v1/recipes/infrastructure-discovery`

Operation: `recipeInfrastructureDiscovery`
Credits and authentication: 15
Authentication required

GET /v1/recipes/infrastructure-discovery Credits: 15

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domain | string | required |
| depth | string Allowed values `quick`, `standard`, `deep` Default `standard` | optional |
| include_historical | boolean Default `false` | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.domain` | string |
| `data.subdomains` | object |
| `data.subdomains.count` | number |
| `data.subdomains.items[]` | object[] |
| `data.subdomains.items[]` | object |
| `data.subdomains.items[].subdomain` | string |
| `data.subdomains.items[].ip` | string |
| `data.subdomains.items[].tech[]` | string[] |
| `data.ip_addresses` | object |
| `data.ip_addresses.unique_ips` | number |
| `data.ip_addresses.items[]` | object[] |
| `data.ip_addresses.items[]` | object |
| `data.ip_addresses.items[].ip` | string |
| `data.ip_addresses.items[].asn` | string |
| `data.ip_addresses.items[].org` | string |
| `data.ip_addresses.items[].country` | string |
| `data.hosting` | object |
| `data.hosting.providers[]` | string[] |
| `data.hosting.regions[]` | string[] |
| `data.related_domains[]` | string[] |
| `data.technology_summary` | object |
| `data.technology_summary.cms` | null |
| `data.technology_summary.frameworks[]` | string[] |
| `data.technology_summary.servers[]` | string[] |
| `data.technology_summary.cdn` | string |
| `data.attack_surface` | object |
| `data.attack_surface.exposed_services[]` | string[] |
| `data.attack_surface.potential_entry_points[]` | string[] |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | array |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/infrastructure-discovery?domain=example.com&depth=standard&include_historical=false"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/infrastructure-discovery?domain=example.com&depth=standard&include_historical=false", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/infrastructure-discovery?domain=example.com&depth=standard&include_historical=false",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/infrastructure-discovery?domain=example.com&depth=standard&include_historical=false", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/infrastructure-discovery?domain=example.com&depth=standard&include_historical=false")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Example response

```json
{
  "success": true,
  "data": {
    "domain": "example.com",
    "subdomains": {
      "count": 4,
      "items": [
        {
          "subdomain": "api.example.com",
          "ip": "198.51.100.44",
          "tech": [
            "nginx",
            "Node.js"
          ]
        }
      ]
    },
    "ip_addresses": {
      "unique_ips": 2,
      "items": [
        {
          "ip": "198.51.100.44",
          "asn": "AS13335",
          "org": "Cloudflare, Inc.",
          "country": "US"
        }
      ]
    },
    "hosting": {
      "providers": [
        "Cloudflare",
        "Vercel"
      ],
      "regions": [
        "US",
        "EU"
      ]
    },
    "related_domains": [
      "status-example.com"
    ],
    "technology_summary": {
      "cms": null,
      "frameworks": [
        "Next.js"
      ],
      "servers": [
        "nginx"
      ],
      "cdn": "Cloudflare"
    },
    "attack_surface": {
      "exposed_services": [
        "HTTPS",
        "API"
      ],
      "potential_entry_points": [
        "api.example.com",
        "status.example.com"
      ]
    }
  },
  "meta": {
    "recipe_name": "infrastructure-discovery",
    "credits_used": 15,
    "credits_saved": 10,
    "duration_ms": 1084,
    "components_called": [
      "subdomains",
      "ip",
      "tech",
      "certificates"
    ],
    "cached_components": [],
    "timestamp": "2026-04-15T11:07:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## GET `/v1/recipes/defensive-registration`

Operation: `recipeDefensiveRegistration`
Credits and authentication: 12
Authentication required

GET /v1/recipes/defensive-registration Credits: 12

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| brand | string | required |
| owned_domains | string | required |
| priority_tlds | string | optional |
| include_typos | boolean Default `true` | optional |
| budget | number | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.brand` | string |
| `data.summary` | object |
| `data.summary.total_candidates` | number |
| `data.summary.already_owned` | number |
| `data.summary.available` | number |
| `data.summary.registered_by_others` | number |
| `data.summary.within_budget` | number |
| `data.priority_registrations[]` | object[] |
| `data.priority_registrations[]` | object |
| `data.priority_registrations[].domain` | string |
| `data.priority_registrations[].type` | string |
| `data.priority_registrations[].available` | boolean |
| `data.priority_registrations[].risk_if_unowned` | string |
| `data.priority_registrations[].price` | number |
| `data.priority_registrations[].registrar` | string |
| `data.typo_threats[]` | object[] |
| `data.typo_threats[]` | object |
| `data.typo_threats[].domain` | string |
| `data.typo_threats[].type` | string |
| `data.typo_threats[].available` | boolean |
| `data.typo_threats[].risk_if_unowned` | string |
| `data.typo_threats[].price` | null |
| `data.typo_threats[].registrar` | null |
| `data.shopping_cart` | object |
| `data.shopping_cart.domains[]` | string[] |
| `data.shopping_cart.total_cost` | number |
| `data.shopping_cart.within_budget` | boolean |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | string[] |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/defensive-registration?brand=acme&owned_domains=acme.com&priority_tlds=com&include_typos=true&budget=0.5"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/defensive-registration?brand=acme&owned_domains=acme.com&priority_tlds=com&include_typos=true&budget=0.5", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/defensive-registration?brand=acme&owned_domains=acme.com&priority_tlds=com&include_typos=true&budget=0.5",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/defensive-registration?brand=acme&owned_domains=acme.com&priority_tlds=com&include_typos=true&budget=0.5", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/defensive-registration?brand=acme&owned_domains=acme.com&priority_tlds=com&include_typos=true&budget=0.5")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Example response

```json
{
  "success": true,
  "data": {
    "brand": "acme",
    "summary": {
      "total_candidates": 18,
      "already_owned": 3,
      "available": 9,
      "registered_by_others": 6,
      "within_budget": 5
    },
    "priority_registrations": [
      {
        "domain": "acme.io",
        "type": "tld_variant",
        "available": true,
        "risk_if_unowned": "high",
        "price": 39.99,
        "registrar": "porkbun"
      }
    ],
    "typo_threats": [
      {
        "domain": "acm3.com",
        "type": "typo",
        "available": false,
        "risk_if_unowned": "high",
        "price": null,
        "registrar": null
      }
    ],
    "shopping_cart": {
      "domains": [
        "acme.io",
        "acme.co"
      ],
      "total_cost": 63.98,
      "within_budget": true
    }
  },
  "meta": {
    "recipe_name": "defensive-registration",
    "credits_used": 12,
    "credits_saved": 8,
    "duration_ms": 688,
    "components_called": [
      "typosquatting",
      "availability",
      "pricing",
      "tld-intelligence"
    ],
    "cached_components": [
      "pricing"
    ],
    "timestamp": "2026-04-15T11:16:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## GET `/v1/recipes/phishing-investigation`

Operation: `recipePhishingInvestigation`
Credits and authentication: 12
Authentication required

GET /v1/recipes/phishing-investigation Credits: 12

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| suspicious_domain | string | required |
| legitimate_domain | string | optional |
| collect_evidence | boolean Default `true` | optional |
| dry_run | string Allowed values `true` | optional |

#### Response fields

| Field | Type |
| --- | --- |
| `success` | boolean |
| `data` | object |
| `data.suspicious_domain` | string |
| `data.legitimate_domain` | string |
| `data.verdict` | string |
| `data.confidence` | number |
| `data.indicators` | object |
| `data.indicators.typosquatting` | object |
| `data.indicators.typosquatting.detected` | boolean |
| `data.indicators.typosquatting.technique` | string |
| `data.indicators.domain_age` | object |
| `data.indicators.domain_age.days` | number |
| `data.indicators.domain_age.risk` | string |
| `data.indicators.registration` | object |
| `data.indicators.registration.privacy_protected` | boolean |
| `data.indicators.registration.registrar` | string |
| `data.indicators.registration.created_date` | string |
| `data.indicators.infrastructure` | object |
| `data.indicators.infrastructure.ip` | string |
| `data.indicators.infrastructure.hosting` | string |
| `data.indicators.infrastructure.geolocation` | string |
| `data.indicators.ssl` | object |
| `data.indicators.ssl.valid` | boolean |
| `data.indicators.ssl.issuer` | string |
| `data.indicators.ssl.age_days` | number |
| `data.indicators.reputation` | object |
| `data.indicators.reputation.blocklisted` | boolean |
| `data.indicators.reputation.similar_reports` | number |
| `data.comparison_to_legitimate` | object |
| `data.comparison_to_legitimate.similarity_score` | number |
| `data.comparison_to_legitimate.visual_differences[]` | string[] |
| `data.evidence_package` | object |
| `data.evidence_package.dns_snapshot` | object |
| `data.evidence_package.dns_snapshot.A[]` | string[] |
| `data.evidence_package.whois_snapshot` | object |
| `data.evidence_package.whois_snapshot.registrar` | string |
| `data.evidence_package.timestamp` | string |
| `data.recommended_actions[]` | string[] |
| `meta` | object |
| `meta.recipe_name` | string |
| `meta.credits_used` | number |
| `meta.credits_saved` | number |
| `meta.duration_ms` | number |
| `meta.components_called[]` | string[] |
| `meta.cached_components[]` | array |
| `meta.timestamp` | string |
| `errors[]` | array |

#### Example request

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/phishing-investigation?suspicious_domain=examp1e.com&legitimate_domain=example.com&collect_evidence=true"
```

```javascript
const response = await fetch("https://domscan.net/v1/recipes/phishing-investigation?suspicious_domain=examp1e.com&legitimate_domain=example.com&collect_evidence=true", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.get(
    "https://domscan.net/v1/recipes/phishing-investigation?suspicious_domain=examp1e.com&legitimate_domain=example.com&collect_evidence=true",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
```

```go
package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/recipes/phishing-investigation?suspicious_domain=examp1e.com&legitimate_domain=example.com&collect_evidence=true", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}
```

```ruby
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/recipes/phishing-investigation?suspicious_domain=examp1e.com&legitimate_domain=example.com&collect_evidence=true")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))
```

#### Example response

```json
{
  "success": true,
  "data": {
    "suspicious_domain": "examp1e.com",
    "legitimate_domain": "example.com",
    "verdict": "confirmed_phishing",
    "confidence": 0.93,
    "indicators": {
      "typosquatting": {
        "detected": true,
        "technique": "character_swap"
      },
      "domain_age": {
        "days": 3,
        "risk": "high"
      },
      "registration": {
        "privacy_protected": true,
        "registrar": "Example Registrar",
        "created_date": "2026-04-12"
      },
      "infrastructure": {
        "ip": "203.0.113.18",
        "hosting": "Suspicious Hosting Ltd.",
        "geolocation": "NL"
      },
      "ssl": {
        "valid": true,
        "issuer": "Let's Encrypt",
        "age_days": 2
      },
      "reputation": {
        "blocklisted": true,
        "similar_reports": 4
      }
    },
    "comparison_to_legitimate": {
      "similarity_score": 0.97,
      "visual_differences": [
        "digit-substitution in second label character"
      ]
    },
    "evidence_package": {
      "dns_snapshot": {
        "A": [
          "203.0.113.18"
        ]
      },
      "whois_snapshot": {
        "registrar": "Example Registrar"
      },
      "timestamp": "2026-04-15T11:24:00Z"
    },
    "recommended_actions": [
      "Report to registrar abuse contact",
      "Submit URL to Safe Browsing and internal blocklists"
    ]
  },
  "meta": {
    "recipe_name": "phishing-investigation",
    "credits_used": 12,
    "credits_saved": 10,
    "duration_ms": 952,
    "components_called": [
      "whois",
      "dns",
      "ip",
      "reputation",
      "health",
      "certificates"
    ],
    "cached_components": [],
    "timestamp": "2026-04-15T11:24:00Z"
  },
  "errors": []
}
```

#### HTTP status codes

- `200` OK
- `400` Bad Request
- `401` Unauthorized
- `402` Payment Required
- `429` Too Many Requests

## Reference resources

[OpenAPI 3.0](https://domscan.net/v1/openapi.json)
[Postman](https://domscan.net/v1/postman.json)
[MCP](https://domscan.net/mcp-domain-checker)
