> 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/ru/docs/products/workflow-recipes

# API Рецепты рабочего процесса

Предварительно созданные рабочие процессы API для обычных задач интеллектуального анализа доменов. Каждый рецепт объединяет несколько эндпоинтов для достижения определенной цели. Используйте этот справочник, чтобы выбрать нужный эндпоинт и точно увидеть, что он возвращает.

[Открыть страницу продукта](https://domscan.net/ru/workflow-recipes-api)

## Операции

GET `/v1/recipes/due-diligence` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipeDueDiligence)

GET `/v1/recipes/brand-launch` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipeBrandLaunch)

GET `/v1/recipes/threat-assessment` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipeThreatAssessment)

GET `/v1/recipes/domain-finder` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipeDomainFinder)

GET `/v1/recipes/competitor-intel` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipeCompetitorIntel)

GET `/v1/recipes/portfolio-audit` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipePortfolioAudit)

POST `/v1/recipes/portfolio-audit` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipePortfolioAuditPost)

GET `/v1/recipes/email-deliverability` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipeEmailDeliverability)

GET `/v1/recipes/dns-migration` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipeDnsMigration)

GET `/v1/recipes/infrastructure-discovery` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipeInfrastructureDiscovery)

GET `/v1/recipes/defensive-registration` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipeDefensiveRegistration)

GET `/v1/recipes/phishing-investigation` [Открыть справочник API](https://domscan.net/ru/docs/products/workflow-recipes#recipePhishingInvestigation)

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

Операция: `recipeDueDiligence`
Кредиты и аутентификация: 12
Требуется аутентификация

GET /v1/recipes/due-diligence Кредиты: 12

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| domain | string | обязателен |
| include_competitors | boolean По умолчанию `false` | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

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

Операция: `recipeBrandLaunch`
Кредиты и аутентификация: 10
Требуется аутентификация

GET /v1/recipes/brand-launch Кредиты: 10

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| domain | string | обязателен |
| brand_name | string | опционально |
| platforms | string | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

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

Операция: `recipeThreatAssessment`
Кредиты и аутентификация: 18
Требуется аутентификация

GET /v1/recipes/threat-assessment Кредиты: 18

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| domain | string | обязателен |
| analyze_threats | boolean По умолчанию `true` | опционально |
| max_threats | integer По умолчанию `10` | опционально |
| include_evidence | boolean По умолчанию `true` | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

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

Операция: `recipeDomainFinder`
Кредиты и аутентификация: 12
Требуется аутентификация

GET /v1/recipes/domain-finder Кредиты: 12

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| keywords | string | обязателен |
| tlds | string | опционально |
| style | string Допустимые значения `brandable`, `keyword-rich`, `short` | опционально |
| max_length | integer | опционально |
| language | string Допустимые значения `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` По умолчанию `en` | опционально |
| limit | integer По умолчанию `20` | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

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

Операция: `recipeCompetitorIntel`
Кредиты и аутентификация: 15
Требуется аутентификация

GET /v1/recipes/competitor-intel Кредиты: 15

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| domain | string | обязателен |
| discover_subdomains | boolean По умолчанию `true` | опционально |
| analyze_infrastructure | boolean По умолчанию `true` | опционально |
| analyze_email | boolean По умолчанию `true` | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

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

Операция: `recipePortfolioAudit`
Кредиты и аутентификация: 25
Требуется аутентификация

GET /v1/recipes/portfolio-audit Кредиты: 25

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| domains | string | обязателен |
| include_valuation | boolean По умолчанию `true` | опционально |
| include_health | boolean По умолчанию `true` | опционально |
| include_pricing | boolean По умолчанию `true` | опционально |
| alert_expiring_days | integer По умолчанию `90` | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

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

Операция: `recipePortfolioAuditPost`
Кредиты и аутентификация: 25
Требуется аутентификация

POST /v1/recipes/portfolio-audit Кредиты: 25

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| dry_run | string Допустимые значения `true` | опционально |

#### Параметры тела запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| domains | string[] | обязателен |
| include_valuation | boolean По умолчанию `true` | опционально |
| include_health | boolean По умолчанию `true` | опционально |
| include_pricing | boolean По умолчанию `true` | опционально |
| alert_expiring_days | integer По умолчанию `90` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `409` HTTP 409
- `422` HTTP 422
- `429` Слишком много запросов

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

Операция: `recipeEmailDeliverability`
Кредиты и аутентификация: 10
Требуется аутентификация

GET /v1/recipes/email-deliverability Кредиты: 10

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| domain | string | обязателен |
| dkim_selectors | string | опционально |
| check_blacklists | boolean По умолчанию `true` | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

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

Операция: `recipeDnsMigration`
Кредиты и аутентификация: 7
Требуется аутентификация

GET /v1/recipes/dns-migration Кредиты: 7

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| domain | string | обязателен |
| target_nameservers | string | опционально |
| critical_records | string | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

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

Операция: `recipeInfrastructureDiscovery`
Кредиты и аутентификация: 15
Требуется аутентификация

GET /v1/recipes/infrastructure-discovery Кредиты: 15

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| domain | string | обязателен |
| depth | string Допустимые значения `quick`, `standard`, `deep` По умолчанию `standard` | опционально |
| include_historical | boolean По умолчанию `false` | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

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

Операция: `recipeDefensiveRegistration`
Кредиты и аутентификация: 12
Требуется аутентификация

GET /v1/recipes/defensive-registration Кредиты: 12

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| brand | string | обязателен |
| owned_domains | string | обязателен |
| priority_tlds | string | опционально |
| include_typos | boolean По умолчанию `true` | опционально |
| budget | number | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

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

Операция: `recipePhishingInvestigation`
Кредиты и аутентификация: 12
Требуется аутентификация

GET /v1/recipes/phishing-investigation Кредиты: 12

#### Параметры запроса

| Параметр | Тип | обязателен |
| --- | --- | --- |
| suspicious_domain | string | обязателен |
| legitimate_domain | string | опционально |
| collect_evidence | boolean По умолчанию `true` | опционально |
| dry_run | string Допустимые значения `true` | опционально |

#### Поля ответа

| Поле | Тип |
| --- | --- |
| `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 |

#### Пример запроса

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

#### Пример ответа

```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

- `200` OK
- `400` Неверный запрос
- `401` Не авторизован
- `402` Требуется оплата
- `429` Слишком много запросов

## Справочные материалы

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