> 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/pl/docs/domain-profile

# Profil domeny

Poznaj dokumentację API Profil domeny, parametry żądań, pola odpowiedzi, przykłady kodu i obsługę błędów w integracjach DomScan.

Uzyskaj znormalizowane dane rejestracji RDAP, w tym rejestratora, datę utworzenia, wygaśnięcia, serwery nazw, status DNSSEC i podsumowanie kontaktów. Zawiera także wiek domeny i liczbę dni do wygaśnięcia.

GET /v1/profile

#### Parametry zapytania

| Parametr | Typ | Opis |
| --- | --- | --- |
| domain wymagane | string | Pełna nazwa domeny, np. github.com |

#### Pola odpowiedzi

| Pole | Typ | Opis |
| --- | --- | --- |
| `age_days` | number | Wiek domeny w dniach od rejestracji |
| `days_until_expiry` | number | Liczba dni do wygaśnięcia domeny |
| `dnssec` | boolean | Czy DNSSEC jest włączony |
| `status` | array | Kody statusu EPP, np. clientDeleteProhibited |

#### Przykładowe żądanie

```bash
curl -H "X-API-Key: your-api-key" "https://domscan.net/v1/profile?domain=github.com"
```

```javascript
const domscanFetch = (url, options = {}) =>
  fetch(url, {
    ...options,
    headers: { ...options.headers, "X-API-Key": "your-api-key" },
  });

const response = await domscanFetch(
  "https://domscan.net/v1/profile?domain=github.com"
);
const data = await response.json();

console.log(`Domain age: ${data.age_days} days`);
console.log(`Expires in: ${data.days_until_expiry} days`);
console.log(`DNSSEC: ${data.dnssec ? 'Enabled' : 'Disabled'}`);
```

```python
import requests

domscan = requests.Session()
domscan.headers.update({"X-API-Key": "your-api-key"})

response = domscan.get(
    "https://domscan.net/v1/profile",
    params={"domain": "github.com"}
)
data = response.json()

print(f"Domain age: {data['age_days']} days ({data['age_days'] // 365} years)")
print(f"Expires in: {data['days_until_expiry']} days")
```

#### Przykładowa odpowiedź

```json
{
  "domain": "github.com",
  "registered": true,
  "registrar": "MarkMonitor Inc.",
  "registrar_url": "https://www.markmonitor.com",
  "created_date": "2007-10-09T18:20:50Z",
  "updated_date": "2024-09-08T09:19:27Z",
  "expiry_date": "2026-10-09T07:00:00Z",
  "age_days": 6310,
  "days_until_expiry": 628,
  "nameservers": ["dns1.p08.nsone.net", "dns2.p08.nsone.net"],
  "dnssec": true,
  "status": ["clientDeleteProhibited", "clientTransferProhibited"],
  "contacts": {
    "registrant_name": "GitHub, Inc.",
    "registrant_org": "GitHub, Inc.",
    "registrant_country": "US"
  },
  "privacy": {
    "is_private": false,
    "privacy_service": null
  }
}
```

POST /v1/profile/bulk Kredyty: 3/item

#### Parametry zapytania

| Parametr | Typ | wymagane |
| --- | --- | --- |
| dry_run | string Dozwolone wartości `true` | opcjonalne |

#### Parametry treści

| Parametr | Typ | wymagane |
| --- | --- | --- |
| domains | string[] | wymagane |

#### Pola odpowiedzi

| Pole | Typ |
| --- | --- |
| `results[]` | unknown[] |
| `meta` | object |
| `meta.total` | integer |
| `meta.succeeded` | integer |
| `meta.failed` | integer |
| `meta.max_items` | integer |
| `meta.credits_per_item` | integer |
| `meta.duration_ms` | integer |

#### Przykładowe żądanie

```bash
curl -X POST "https://domscan.net/v1/profile/bulk" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "domains": [
    "example.com",
    "cloudflare.com"
  ]
}'
```

```javascript
const response = await fetch("https://domscan.net/v1/profile/bulk", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "domains": [
      "example.com",
      "cloudflare.com"
    ]
  }),
});
const data = await response.json();
console.log(data);
```

```python
import os
import requests

response = requests.post(
    "https://domscan.net/v1/profile/bulk",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "domains": [
            "example.com",
            "cloudflare.com",
        ],
    },
)
print(response.json())
```

```go
package main

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

func main() {
	body := strings.NewReader(`{
	  "domains": [
	    "example.com",
	    "cloudflare.com"
	  ]
	}`)
	req, err := http.NewRequest(http.MethodPost, "https://domscan.net/v1/profile/bulk", 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/profile/bulk")
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",
    "cloudflare.com"
  ]
})

#### Przykładowa odpowiedź

```json
{
  "results": [
    {
      "input": "example",
      "data": {}
    }
  ],
  "meta": {
    "total": 1,
    "succeeded": 1,
    "failed": 1,
    "max_items": 10,
    "credits_per_item": 1,
    "duration_ms": 1
  }
}
```

#### Kody statusu HTTP

- `200` OK
- `400` Nieprawidłowe żądanie
- `401` Nieautoryzowany
- `402` Wymagana płatność
- `409` HTTP 409
- `422` HTTP 422
- `429` Zbyt wiele żądań

GET /v1/overview Kredyty: 5

#### Parametry zapytania

| Parametr | Typ | wymagane |
| --- | --- | --- |
| domain | string | wymagane |

#### Pola odpowiedzi

| Pole | Typ |
| --- | --- |
| `domain` | string |
| `health` | object |
| `health.dns_ok` | boolean \| null |
| `health.https_ok` | boolean \| null |
| `dns` | object |
| `dns.has_a` | boolean \| null |
| `dns.has_aaaa` | boolean \| null |
| `dns.has_mx` | boolean \| null |
| `dns.nameservers[]` | string[] |
| `registration` | object |
| `registration.registered` | boolean \| null |
| `registration.registrar` | string \| null |
| `registration.created_date` | string \| null |
| `registration.expiry_date` | string \| null |
| `registration.age_days` | integer \| null |
| `registration.days_until_expiry` | integer \| null |
| `registration.dnssec` | boolean \| null |
| `reputation` | object |
| `reputation.score` | number \| null |
| `reputation.grade` | string \| null |
| `popularity` | object |
| `popularity.rank` | integer \| null |
| `popularity.bucket` | string \| null |
| `component_freshness` | object |
| `component_freshness.cache_status` | string |
| `component_freshness.checked_at` | string |
| `component_freshness.component_count` | integer |
| `component_freshness.fresh_component_count` | integer |
| `component_freshness.degraded_component_count` | integer |
| `component_freshness.components` | object |
| `component_freshness.components.health` | object |
| `component_freshness.components.health.source` | string |
| `component_freshness.components.health.state` | string |
| `component_freshness.components.health.checked_at` | string |
| `component_freshness.components.health.evidence_count` | integer |
| `component_freshness.components.health.reason` | string \| null |
| `component_freshness.components.dns` | object |
| `component_freshness.components.dns.source` | string |
| `component_freshness.components.dns.state` | string |
| `component_freshness.components.dns.checked_at` | string |
| `component_freshness.components.dns.evidence_count` | integer |
| `component_freshness.components.dns.reason` | string \| null |
| `component_freshness.components.registration` | object |
| `component_freshness.components.registration.source` | string |
| `component_freshness.components.registration.state` | string |
| `component_freshness.components.registration.checked_at` | string |
| `component_freshness.components.registration.evidence_count` | integer |
| `component_freshness.components.registration.reason` | string \| null |
| `component_freshness.components.reputation` | object |
| `component_freshness.components.reputation.source` | string |
| `component_freshness.components.reputation.state` | string |
| `component_freshness.components.reputation.checked_at` | string |
| `component_freshness.components.reputation.evidence_count` | integer |
| `component_freshness.components.reputation.reason` | string \| null |
| `component_freshness.components.popularity` | object |
| `component_freshness.components.popularity.source` | string |
| `component_freshness.components.popularity.state` | string |
| `component_freshness.components.popularity.checked_at` | string |
| `component_freshness.components.popularity.evidence_count` | integer |
| `component_freshness.components.popularity.reason` | string \| null |
| `query_time_ms` | integer |
| `checked_at` | string |
| `meta` | object |
| `meta.served_by` | string |
| `meta.cached` | boolean |

#### Przykładowe żądanie

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/overview?domain=example.com"
```

```javascript
const response = await fetch("https://domscan.net/v1/overview?domain=example.com", {
  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/overview?domain=example.com",
    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/overview?domain=example.com", 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/overview?domain=example.com")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Przykładowa odpowiedź

```json
{
  "domain": "example.com",
  "health": {
    "dns_ok": true,
    "https_ok": true
  },
  "dns": {
    "has_a": true,
    "has_aaaa": true,
    "has_mx": false,
    "nameservers": [
      "ns1.example.net",
      "ns2.example.net"
    ]
  },
  "registration": {
    "registered": true,
    "registrar": "Example Registrar, Inc.",
    "created_date": "2019-03-11T14:22:08Z",
    "expiry_date": "2027-03-11T14:22:08Z",
    "age_days": 2769,
    "days_until_expiry": 153,
    "dnssec": false
  },
  "reputation": {
    "score": 82,
    "grade": "A"
  },
  "popularity": {
    "rank": 18452,
    "bucket": "top-100k"
  },
  "component_freshness": {
    "cache_status": "miss",
    "checked_at": "2026-10-09T10:15:30.000Z",
    "component_count": 5,
    "fresh_component_count": 5,
    "degraded_component_count": 0,
    "components": {
      "health": {
        "source": "quick_health",
        "state": "fresh",
        "checked_at": "2026-10-09T10:15:30.000Z",
        "evidence_count": 2
      },
      "dns": {
        "source": "dns",
        "state": "fresh",
        "checked_at": "2026-10-09T10:15:30.000Z",
        "evidence_count": 4
      },
      "registration": {
        "source": "rdap",
        "state": "fresh",
        "checked_at": "2026-10-09T10:15:30.000Z",
        "evidence_count": 7
      },
      "reputation": {
        "source": "reputation",
        "state": "fresh",
        "checked_at": "2026-10-09T10:15:30.000Z",
        "evidence_count": 2
      },
      "popularity": {
        "source": "popularity",
        "state": "fresh",
        "checked_at": "2026-10-09T10:15:30.000Z",
        "evidence_count": 2
      }
    }
  },
  "query_time_ms": 1840,
  "checked_at": "2026-10-09T10:15:30.000Z",
  "meta": {
    "served_by": "pop=MAD country=ES",
    "cached": false
  }
}
```

#### Kody statusu HTTP

- `200` OK
- `400` Nieprawidłowe żądanie
- `401` Nieautoryzowany
- `402` Wymagana płatność
- `429` Zbyt wiele żądań

GET /v1/popularity Kredyty: 2

#### Parametry zapytania

| Parametr | Typ | wymagane |
| --- | --- | --- |
| domain | string | wymagane |
| include_history | boolean Domyślnie `false` | opcjonalne |
| history_limit | integer Domyślnie `30` | opcjonalne |

#### Pola odpowiedzi

| Pole | Typ |
| --- | --- |
| `domain` | string |
| `status` | string |
| `rank` | integer \| null |
| `bucket` | string |
| `source` | object |
| `source.id` | string |
| `source.url` | string |
| `source.list_date` | string \| null |
| `source.provenance` | object |
| `source.provenance.owner` | string |
| `source.provenance.source_url` | string |
| `source.provenance.methodology_url` | string |
| `source.provenance.access_method` | string |
| `source.provenance.cost` | string |
| `source.provenance.runtime_rate_limits` | string |
| `source.provenance.terms_status` | string |
| `source.provenance.expected_freshness` | string |
| `source.provenance.maintenance_risk` | string |
| `source.provenance.fallback_behavior` | string |
| `source.provenance.last_verified` | string |
| `freshness` | object |
| `freshness.cache_status` | string |
| `freshness.ttl_seconds` | integer |
| `checked_at` | string |
| `result_count` | integer \| null |
| `empty_result` | boolean |
| `history` | object |
| `history.collection` | string |
| `history.complete_daily_series` | boolean |
| `history.available` | boolean |
| `history.observations[]` | object[] |
| `history.observations[]` | object |
| `history.observations[].domain` | string |
| `history.observations[].rank` | integer \| null |
| `history.observations[].bucket` | string |
| `history.observations[].status` | string |
| `history.observations[].source` | string |
| `history.observations[].list_date` | string \| null |
| `history.observations[].observed_on` | string |
| `history.observations[].checked_at` | string |

#### Przykładowe żądanie

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/popularity?domain=example.com&include_history=false&history_limit=30"
```

```javascript
const response = await fetch("https://domscan.net/v1/popularity?domain=example.com&include_history=false&history_limit=30", {
  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/popularity?domain=example.com&include_history=false&history_limit=30",
    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/popularity?domain=example.com&include_history=false&history_limit=30", 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/popularity?domain=example.com&include_history=false&history_limit=30")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

#### Przykładowa odpowiedź

```json
{
  "domain": "example.com",
  "status": "ranked",
  "rank": 18452,
  "bucket": "top-100k",
  "source": {
    "id": "tranco",
    "url": "https://tranco-list.eu/",
    "list_date": "2026-10-08",
    "provenance": {
      "owner": "Tranco research project",
      "source_url": "https://tranco-list.eu/",
      "methodology_url": "https://tranco-list.eu/methodology",
      "access_method": "public_domain_rank_api",
      "cost": "none",
      "runtime_rate_limits": "not_published_cached_and_bounded_by_domscan",
      "terms_status": "mixed_upstream_licenses_review_required_for_commercial_reuse",
      "expected_freshness": "daily",
      "maintenance_risk": "medium",
      "fallback_behavior": "return_unknown_without_inventing_or_reusing_an_unranked_result",
      "last_verified": "2026-08-02"
    }
  },
  "freshness": {
    "cache_status": "miss",
    "ttl_seconds": 86400
  },
  "checked_at": "2026-10-09T10:15:30.000Z",
  "result_count": 1,
  "empty_result": false,
  "history": {
    "collection": "lookup_driven",
    "complete_daily_series": false,
    "available": true,
    "observations": [
      {
        "domain": "example.com",
        "rank": 18452,
        "bucket": "top-100k",
        "status": "ranked",
        "source": "tranco",
        "list_date": "2026-10-08",
        "observed_on": "2026-10-09",
        "checked_at": "2026-10-09T10:15:30.000Z"
      },
      {
        "domain": "example.com",
        "rank": 18877,
        "bucket": "top-100k",
        "status": "ranked",
        "source": "tranco",
        "list_date": "2026-10-01",
        "observed_on": "2026-10-02",
        "checked_at": "2026-10-02T10:15:30.000Z"
      }
    ]
  }
}
```

#### Kody statusu HTTP

- `200` OK
- `400` Nieprawidłowe żądanie
- `401` Nieautoryzowany
- `402` Wymagana płatność
- `429` Zbyt wiele żądań

GET /v1/popularity/history Kredyty: 1

#### Parametry zapytania

| Parametr | Typ | wymagane |
| --- | --- | --- |
| domain | string | wymagane |
| limit | integer Domyślnie `30` | opcjonalne |

#### Pola odpowiedzi

| Pole | Typ |
| --- | --- |
| `domain` | string |
| `collection` | string |
| `complete_daily_series` | boolean |
| `result_count` | integer |
| `empty_result` | boolean |
| `observations[]` | object[] |
| `observations[]` | object |
| `observations[].domain` | string |
| `observations[].rank` | integer \| null |
| `observations[].bucket` | string |
| `observations[].status` | string |
| `observations[].source` | string |
| `observations[].list_date` | string \| null |
| `observations[].observed_on` | string |
| `observations[].checked_at` | string |

#### Przykładowe żądanie

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/popularity/history?domain=example.com&limit=25"
```

```javascript
const response = await fetch("https://domscan.net/v1/popularity/history?domain=example.com&limit=25", {
  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/popularity/history?domain=example.com&limit=25",
    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/popularity/history?domain=example.com&limit=25", 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/popularity/history?domain=example.com&limit=25")
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))
```

#### Przykładowa odpowiedź

```json
{
  "domain": "example.com",
  "collection": "lookup_driven",
  "complete_daily_series": false,
  "result_count": 1,
  "empty_result": false,
  "observations": [
    {
      "domain": "example.com",
      "rank": 1,
      "bucket": "top-100",
      "status": "ranked",
      "source": "tranco",
      "list_date": "2026-08-27",
      "observed_on": "2026-08-27",
      "checked_at": "2026-08-27T12:00:00Z"
    }
  ]
}
```

#### Kody statusu HTTP

- `200` OK
- `400` Nieprawidłowe żądanie
- `401` Nieautoryzowany
- `402` Wymagana płatność
- `429` Zbyt wiele żądań
- `500` Błąd serwera
