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

# Profil de domaine

Consultez la documentation de l'API Profil de domaine, ses paramètres de requête, les champs de réponse, les exemples de code et la gestion des erreurs pour les intégrations DomScan.

Obtenez des données d'enregistrement RDAP normalisées incluant le registraire, la date de création, l'expiration, les serveurs de noms, le statut DNSSEC et un résumé des contacts. Comprend aussi l'âge du domaine et le nombre de jours avant l'expiration.

GET /v1/profile

#### Paramètres de requête

| Paramètre | Type | Description |
| --- | --- | --- |
| domain requis | string | Nom de domaine complet (par exemple, github.com) |

#### Champs de réponse

| Champ | Type | Description |
| --- | --- | --- |
| `age_days` | number | Âge du domaine en jours depuis l'enregistrement |
| `days_until_expiry` | number | Jours jusqu'à l'expiration du domaine |
| `dnssec` | boolean | Si DNSSEC est activé |
| `status` | array | Codes d'état EPP (clientDeleteProhibited, etc.) |

#### Exemple de requête

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

#### Exemple de réponse

```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 Crédits: 3/item

#### Paramètres de requête

| Paramètre | Type | requis |
| --- | --- | --- |
| dry_run | string Valeurs autorisées `true` | optionnel |

#### Paramètres du corps

| Paramètre | Type | requis |
| --- | --- | --- |
| domains | string[] | requis |

#### Champs de réponse

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

#### Exemple de requête

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

#### Exemple de réponse

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

#### Codes de statut HTTP

- `200` OK
- `400` Requête incorrecte
- `401` Non autorisé
- `402` Paiement requis
- `409` HTTP 409
- `422` HTTP 422
- `429` Trop de requêtes

GET /v1/overview Crédits: 5

#### Paramètres de requête

| Paramètre | Type | requis |
| --- | --- | --- |
| domain | string | requis |

#### Champs de réponse

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

#### Exemple de requête

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

#### Exemple de réponse

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

#### Codes de statut HTTP

- `200` OK
- `400` Requête incorrecte
- `401` Non autorisé
- `402` Paiement requis
- `429` Trop de requêtes

GET /v1/popularity Crédits: 2

#### Paramètres de requête

| Paramètre | Type | requis |
| --- | --- | --- |
| domain | string | requis |
| include_history | boolean Défaut `false` | optionnel |
| history_limit | integer Défaut `30` | optionnel |

#### Champs de réponse

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

#### Exemple de requête

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

#### Exemple de réponse

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

#### Codes de statut HTTP

- `200` OK
- `400` Requête incorrecte
- `401` Non autorisé
- `402` Paiement requis
- `429` Trop de requêtes

GET /v1/popularity/history Crédits: 1

#### Paramètres de requête

| Paramètre | Type | requis |
| --- | --- | --- |
| domain | string | requis |
| limit | integer Défaut `30` | optionnel |

#### Champs de réponse

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

#### Exemple de requête

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

#### Exemple de réponse

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

#### Codes de statut HTTP

- `200` OK
- `400` Requête incorrecte
- `401` Non autorisé
- `402` Paiement requis
- `429` Trop de requêtes
- `500` Erreur serveur
