> 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/products/dns-propagation

# API Comparaison des résolveurs DNS

Compare les réponses des résolveurs DNS récursifs publics de Cloudflare et Google. Il s’agit de deux fournisseurs DoH en anycast mondial, pas de sondes géographiques ni de serveurs de noms faisant autorité. Utilisez cette référence pour choisir le bon endpoint et voir exactement ce qu'il renvoie.

[Voir la page du produit](https://domscan.net/fr/dns-propagation)

## Opérations

GET `/v1/dns/propagation` [Voir la référence API](https://domscan.net/fr/docs/products/dns-propagation#getDnsPropagation)

POST `/v1/dns/propagation/bulk` [Voir la référence API](https://domscan.net/fr/docs/products/dns-propagation#bulkDnsPropagation)

GET `/v1/dns/servers` [Voir la référence API](https://domscan.net/fr/docs/products/dns-propagation#getDnsServers)

## GET `/v1/dns/propagation`

Opération: `getDnsPropagation`
Crédits et authentification: 2
Authentification requise

GET /v1/dns/propagation Crédits: 2

#### Paramètres de requête

| Paramètre | Type | requis |
| --- | --- | --- |
| domain | string | requis |
| type | string Valeurs autorisées `A`, `AAAA`, `CNAME`, `MX`, `TXT`, `NS`, `SOA` Défaut `A` | optionnel |
| expected | string | optionnel |

#### Champs de réponse

| Champ | Type |
| --- | --- |
| `domain` | string |
| `record_type` | string |
| `expected_value` | string \| null |
| `measurement_scope` | string |
| `percentage_basis` | string |
| `propagation_percentage` | number |
| `fully_propagated` | boolean |
| `consistent` | boolean |
| `unique_values[]` | string[] |
| `results[]` | object[] |
| `results[]` | object |
| `results[].server` | object |
| `results[].server.name` | string |
| `results[].server.ip` | string |
| `results[].server.provider` | string |
| `results[].server.location` | string |
| `results[].server.country` | string |
| `results[].server.scope` | string |
| `results[].server.doh_endpoint` | string |
| `results[].server.documentation_url` | string |
| `results[].server.format` | string |
| `results[].success` | boolean |
| `results[].records[]` | string[] |
| `results[].ttl` | integer \| null |
| `results[].response_time_ms` | integer |
| `results[].error` | string \| null |
| `checked_at` | string |
| `total_duration_ms` | integer |
| `summary` | object |
| `summary.total_servers` | integer |
| `summary.successful` | integer |
| `summary.failed` | integer |
| `summary.matching_expected` | integer |
| `propagation_summary` | object |
| `propagation_summary.measurement_scope` | string |
| `propagation_summary.percentage_basis` | string |
| `propagation_summary.resolver_count` | integer |
| `propagation_summary.successful_count` | integer |
| `propagation_summary.failed_count` | integer |
| `propagation_summary.propagation_percentage` | number |
| `propagation_summary.fully_propagated` | boolean |
| `propagation_summary.consistent` | boolean |
| `propagation_summary.unique_value_count` | integer |
| `propagation_summary.matching_expected_count` | integer |
| `propagation_summary.expected_value_present` | boolean \| null |
| `propagation_summary.countries_checked` | integer |
| `propagation_summary.providers_checked` | integer |
| `propagation_summary.locations_checked` | integer |
| `propagation_summary.slowest_resolver` | string \| null |
| `propagation_summary.slowest_response_ms` | integer \| null |
| `propagation_summary.fastest_response_ms` | integer \| null |
| `propagation_summary.disagreement_count` | integer |
| `propagation_summary.confidence` | string |
| `meta` | object |
| `meta.served_by` | string |

#### Exemple de requête

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/dns/propagation?domain=example.com&type=A&expected=192.0.2.1"
```

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

#### Exemple de réponse

```json
{
  "domain": "example.com",
  "record_type": "A",
  "expected_value": "192.0.2.10",
  "measurement_scope": "configured_recursive_resolvers",
  "percentage_basis": "expected_value_match",
  "propagation_percentage": 100,
  "fully_propagated": true,
  "consistent": true,
  "unique_values": [
    "192.0.2.10"
  ],
  "results": [
    {
      "server": {
        "name": "Cloudflare 1.1.1.1",
        "ip": "1.1.1.1",
        "location": "Global anycast",
        "country": "GLOBAL",
        "provider": "Cloudflare",
        "scope": "global-anycast",
        "doh_endpoint": "https://cloudflare-dns.com/dns-query",
        "documentation_url": "https://developers.cloudflare.com/1.1.1.1/encryption/dns-over-https/make-api-requests/dns-json/",
        "format": "dns-json"
      },
      "success": true,
      "records": [
        "192.0.2.10"
      ],
      "ttl": 300,
      "response_time_ms": 38
    },
    {
      "server": {
        "name": "Google Public DNS",
        "ip": "8.8.8.8",
        "location": "Global anycast",
        "country": "GLOBAL",
        "provider": "Google",
        "scope": "global-anycast",
        "doh_endpoint": "https://dns.google/resolve",
        "documentation_url": "https://developers.google.com/speed/public-dns/docs/doh/json",
        "format": "dns-json"
      },
      "success": true,
      "records": [
        "192.0.2.10"
      ],
      "ttl": 300,
      "response_time_ms": 52
    }
  ],
  "checked_at": "2026-10-09T10:15:30.000Z",
  "total_duration_ms": 61,
  "summary": {
    "total_servers": 2,
    "successful": 2,
    "failed": 0,
    "matching_expected": 2
  },
  "propagation_summary": {
    "measurement_scope": "configured_recursive_resolvers",
    "percentage_basis": "expected_value_match",
    "resolver_count": 2,
    "successful_count": 2,
    "failed_count": 0,
    "propagation_percentage": 100,
    "fully_propagated": true,
    "consistent": true,
    "unique_value_count": 1,
    "matching_expected_count": 2,
    "expected_value_present": true,
    "countries_checked": 1,
    "providers_checked": 2,
    "locations_checked": 1,
    "slowest_resolver": "Google Public DNS",
    "slowest_response_ms": 52,
    "fastest_response_ms": 38,
    "disagreement_count": 0,
    "confidence": "high"
  }
}
```

#### Codes de statut HTTP

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

## POST `/v1/dns/propagation/bulk`

Opération: `bulkDnsPropagation`
Crédits et authentification: 2
Authentification requise

POST /v1/dns/propagation/bulk Crédits: 2/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 |
| type | string Valeurs autorisées `A`, `AAAA`, `CNAME`, `MX`, `TXT`, `NS`, `SOA` Défaut `A` | optionnel |
| expected | string | optionnel |

#### 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/dns/propagation/bulk" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "domains": [
    "example.com",
    "cloudflare.com"
  ],
  "type": "A"
}'
```

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

```python
import os
import requests

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

```go
package main

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

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

#### 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/dns/servers`

Opération: `getDnsServers`
Crédits et authentification: Gratuit
Authentification requise

GET /v1/dns/servers Crédits: 0

#### Champs de réponse

| Champ | Type |
| --- | --- |
| `measurement_scope` | string |
| `geographic_vantage` | boolean |
| `servers[]` | object[] |
| `servers[]` | object |
| `servers[].name` | string |
| `servers[].location` | string |
| `servers[].country` | string |
| `servers[].ip` | string |
| `servers[].provider` | string |
| `servers[].scope` | string |
| `servers[].doh_endpoint` | string |
| `servers[].documentation_url` | string |
| `servers[].format` | string |
| `total` | integer |
| `meta` | object |
| `meta.served_by` | string |

#### Exemple de requête

```bash
curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/dns/servers"
```

```javascript
const response = await fetch("https://domscan.net/v1/dns/servers", {
  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/dns/servers",
    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/dns/servers", 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/dns/servers")
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
{
  "servers": [
    {
      "name": "Cloudflare 1.1.1.1",
      "ip": "1.1.1.1",
      "location": "Global anycast",
      "country": "GLOBAL",
      "provider": "Cloudflare",
      "scope": "global-anycast",
      "doh_endpoint": "https://cloudflare-dns.com/dns-query",
      "documentation_url": "https://developers.cloudflare.com/1.1.1.1/encryption/dns-over-https/make-api-requests/dns-json/",
      "format": "dns-json"
    },
    {
      "name": "Google Public DNS",
      "ip": "8.8.8.8",
      "location": "Global anycast",
      "country": "GLOBAL",
      "provider": "Google",
      "scope": "global-anycast",
      "doh_endpoint": "https://dns.google/resolve",
      "documentation_url": "https://developers.google.com/speed/public-dns/docs/doh/json",
      "format": "dns-json"
    }
  ],
  "total": 2,
  "measurement_scope": "configured_recursive_resolvers",
  "geographic_vantage": false
}
```

#### Codes de statut HTTP

- `200` OK
- `401` Non autorisé
- `429` Trop de requêtes

## Ressources de référence

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