API reference

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.

Operations

GET /v1/recipes/due-diligence View API reference
GET /v1/recipes/brand-launch View API reference
GET /v1/recipes/threat-assessment View API reference
GET /v1/recipes/domain-finder View API reference
GET /v1/recipes/competitor-intel View API reference
GET /v1/recipes/portfolio-audit View API reference
POST /v1/recipes/portfolio-audit View API reference
GET /v1/recipes/email-deliverability View API reference
GET /v1/recipes/dns-migration View API reference
GET /v1/recipes/infrastructure-discovery View API reference
GET /v1/recipes/defensive-registration View API reference
GET /v1/recipes/phishing-investigation View API reference

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

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/due-diligence?domain=example.com&include_competitors=false"
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);
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())
package main

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

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"))

	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))
}
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")

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

{
  "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

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/brand-launch?domain=example.com&brand_name=Example&platforms=github%2Ctwitter"
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);
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())
package main

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

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"))

	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))
}
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")

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

{
  "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

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"
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);
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())
package main

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

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"))

	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))
}
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")

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

{
  "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 brandablekeyword-richshort
optional
max_length integer optional
language string
Allowed values enzhesjadefrptitkoruarhibnidmsthvitrplnlsvdanofielcshuroukhe
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

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"
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);
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())
package main

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

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"))

	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))
}
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")

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

{
  "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

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"
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);
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())
package main

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

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"))

	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))
}
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")

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

{
  "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

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"
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);
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())
package main

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

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"))

	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))
}
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")

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

{
  "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

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
}'
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);
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())
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")

	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))
}
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
})

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

{
  "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

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"
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);
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())
package main

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

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"))

	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))
}
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")

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

{
  "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:[email protected]",
        "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

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"
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);
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())
package main

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

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"))

	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))
}
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")

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

{
  "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 quickstandarddeep
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

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/recipes/infrastructure-discovery?domain=example.com&depth=standard&include_historical=false"
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);
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())
package main

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

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"))

	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))
}
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")

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

{
  "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

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"
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);
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())
package main

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

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"))

	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))
}
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")

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

{
  "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

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"
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);
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())
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))
}
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

{
  "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