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

Source: https://domscan.net/docs/domain-profile

# Domain Profile

DomScan API: Get normalized RDAP registration data including registrar, creation date, expiration, nameservers, DNSSEC status, and contact summary.

Get normalized RDAP registration data including registrar, creation date, expiration, nameservers, DNSSEC status, and contact summary. Also includes domain age and days until expiry.

GET /v1/profile

#### Query parameters

| Parameter | Type | Description |
| --- | --- | --- |
| domain required | string | Full domain name (e.g., github.com) |

#### Response fields

| Field | Type | Description |
| --- | --- | --- |
| `age_days` | number | Domain age in days since registration |
| `days_until_expiry` | number | Days until domain expires |
| `dnssec` | boolean | Whether DNSSEC is enabled |
| `status` | array | EPP status codes (clientDeleteProhibited, etc.) |

#### Example request

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

#### Example response

```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 Credits: 3/item

#### Query parameters

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

#### Body parameters

| Parameter | Type | required |
| --- | --- | --- |
| domains | string[] | required |

#### Response fields

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

#### Example request

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

#### Example response

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

#### HTTP status codes

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

GET /v1/overview Credits: 5

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domain | string | required |

#### Response fields

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

#### Example request

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

#### Example response

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

#### HTTP status codes

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

GET /v1/popularity Credits: 2

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domain | string | required |
| include_history | boolean Default `false` | optional |
| history_limit | integer Default `30` | optional |

#### Response fields

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

#### Example request

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

#### Example response

```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"
      }
    ]
  }
}
```

#### HTTP status codes

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

GET /v1/popularity/history Credits: 1

#### Query parameters

| Parameter | Type | required |
| --- | --- | --- |
| domain | string | required |
| limit | integer Default `30` | optional |

#### Response fields

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

#### Example request

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

#### Example response

```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"
    }
  ]
}
```

#### HTTP status codes

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