> 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/tr/docs/dns-propagation

# DNS Çözümleyici Karşılaştırması

DNS Çözümleyici Karşılaştırması API belgelerini, istek parametrelerini, yanıt alanlarını, kod örneklerini ve DomScan entegrasyonları için hata işlemeyi inceleyin.

Bağımsız olarak sorgulanan iki genel özyinelemeli DoH sağlayıcısından gelen DNS kayıt yanıtlarını karşılaştırın: Cloudflare ve Google. Her ikisi de global-anycast hizmetidir. Sonuçlar istek yolundan sağlayıcı gözlemleridir, coğrafi ölçüm noktaları, yetkili ad sunucusu kontrolleri veya dünya çapında yayılım kanıtı değildir.

GET /v1/dns/propagation

#### Sorgu parametreleri

| Parametre | Tür | Açıklama |
| --- | --- | --- |
| domain gerekli | string | Yapılandırılmış her çözümleyici üzerinden sorgulanacak alan adı (ör. "example.com") |
| type isteğe bağlı | string | Karşılaştırılacak kayıt türü: A, AAAA, CNAME, MX, TXT, NS, SOA (varsayılan: A) |
| expected isteğe bağlı | string | Karşılaştırma temeli olarak kullanılacak isteğe bağlı expected kayıt değeri (ör. yeni IP adresi) |

#### Yanıt alanları

| Alan | Tür | Açıklama |
| --- | --- | --- |
| `propagation_percentage` | number | expected yoksa: en büyük özdeş yanıt grubu tüm yapılandırılmış çözümleyicilere bölünür. expected varsa: tam expected eşleşmeleri tüm yapılandırılmış çözümleyicilere bölünür (0-100). Hatalar paydada kalır. |
| `fully_propagated` | boolean | Tüm yapılandırılmış çözümleyiciler aynı yanıtta birleştiğinde veya expected verilmişse hepsi onunla eşleştiğinde true olur |
| `consistent` | boolean | Yalnızca yapılandırılmış her çözümleyici başarılı olup aynı canonical yanıt kümesini döndürdüğünde true olur |
| `unique_values` | array | Başarılı çözümleyicilerin döndürdüğü benzersiz kayıt değerleri |
| `results` | array | Her çözümleyici için sağlayıcı, kayıtlar, gözlenen TTL, istek yolu yanıt süresi ve hatalar |

#### Örnek istek

```bash
# Compare A records across configured resolvers
curl -H "X-API-Key: your-api-key" "https://domscan.net/v1/dns/propagation?domain=example.com&type=A"

# Compare MX answers against an expected value
curl -H "X-API-Key: your-api-key" "https://domscan.net/v1/dns/propagation?domain=example.com&type=MX&expected=mail.example.com"
```

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

const url = new URL("https://domscan.net/v1/dns/propagation");
url.searchParams.set("domain", "example.com");
url.searchParams.set("type", "A");
url.searchParams.set("expected", "203.0.113.42");

const response = await domscanFetch(url);
const data = await response.json();

// Legacy response field names are retained for API compatibility.
console.log(`Resolver convergence: ${data.propagation_percentage}%`);
console.log(`All configured resolvers match: ${data.fully_propagated}`);

// Check which servers are still showing old values
data.results
  .filter(r => !r.success || !r.records.includes(data.expected_value))
  .forEach(r => console.log(`${r.server.name}: ${r.records}`));
```

```python
import requests

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

response = domscan.get(
    "https://domscan.net/v1/dns/propagation",
    params={"domain": "example.com", "type": "A"}
)
data = response.json()

# Legacy response field names are retained for API compatibility.
print(f"Resolver convergence: {data['propagation_percentage']}%")
print(f"All configured resolvers match: {data['fully_propagated']}")

# Show servers with different values
for result in data['results']:
    print(f"{result['server']['name']}: {result['records']}")
```

```go
package main

import (
  "encoding/json"
  "fmt"
  "net/http"
  "os"
)

func domscanGet(url string) (*http.Response, error) {
  request, err := http.NewRequest(http.MethodGet, url, nil)
  if err != nil {
    return nil, err
  }
  request.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))
  return http.DefaultClient.Do(request)
}

func main() {
  resp, _ := domscanGet("https://domscan.net/v1/dns/propagation?domain=example.com&type=A")
  defer resp.Body.Close()

  var data map[string]interface{}
  json.NewDecoder(resp.Body).Decode(&data)

  // Legacy response field names are retained for API compatibility.
  fmt.Printf("Resolver convergence: %.0f%%\n", data["propagation_percentage"])
  fmt.Printf("All configured resolvers match: %v\n", data["fully_propagated"])
}
```

```ruby
require 'net/http'
require 'json'

uri = URI("https://domscan.net/v1/dns/propagation?domain=example.com&type=A")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(request) }
data = JSON.parse(response.body)

# Legacy response field names are retained for API compatibility.
puts "Resolver convergence: #{data['propagation_percentage']}%"
puts "All configured resolvers match: #{data['fully_propagated']}"
```

#### Örnek yanıt

```json
{
  "domain": "example.com",
  "record_type": "A",
  "measurement_scope": "configured_recursive_resolvers",
  "percentage_basis": "resolver_convergence",
  "propagation_percentage": 100,
  "fully_propagated": true,
  "consistent": true,
  "unique_values": ["93.184.216.34"],
  "results": [
    {
      "server": {
        "name": "Cloudflare 1.1.1.1",
        "ip": "1.1.1.1",
        "provider": "Cloudflare",
        "location": "Global anycast",
        "country": "GLOBAL",
        "scope": "global-anycast",
        "doh_endpoint": "https://cloudflare-dns.com/dns-query"
      },
      "success": true,
      "records": ["93.184.216.34"],
      "ttl": 86400,
      "response_time_ms": 12
    },
    {
      "server": {
        "name": "Google Public DNS",
        "ip": "8.8.8.8",
        "provider": "Google",
        "location": "Global anycast",
        "country": "GLOBAL",
        "scope": "global-anycast",
        "doh_endpoint": "https://dns.google/resolve"
      },
      "success": true,
      "records": ["93.184.216.34"],
      "ttl": 86400,
      "response_time_ms": 15
    }
  ],
  "summary": {
    "total_servers": 2,
    "successful": 2,
    "failed": 0
  }
}
```

GET /v1/dns/servers

Karşılaştırmada kullanılan iki genel özyinelemeli DoH sağlayıcısını listeleyin: Cloudflare ve Google. Her ikisi de global-anycast çözümleyicisidir, coğrafi ölçüm noktası veya yetkili ad sunucusu değildir.

#### Örnek yanıt

```json
{
  "measurement_scope": "configured_recursive_resolvers",
  "geographic_vantage": false,
  "servers": [
    {
      "name": "Cloudflare 1.1.1.1",
      "ip": "1.1.1.1",
      "provider": "Cloudflare",
      "location": "Global anycast",
      "country": "GLOBAL",
      "scope": "global-anycast",
      "doh_endpoint": "https://cloudflare-dns.com/dns-query"
    },
    {
      "name": "Google Public DNS",
      "ip": "8.8.8.8",
      "provider": "Google",
      "location": "Global anycast",
      "country": "GLOBAL",
      "scope": "global-anycast",
      "doh_endpoint": "https://dns.google/resolve"
    }
  ],
  "total": 2
}
```

#### Yanıt alanları

| Alan | Tür |
| --- | --- |
| `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 |

POST /v1/dns/propagation/bulk Kredi: 2/item

#### Sorgu parametreleri

| Parametre | Tür | gerekli |
| --- | --- | --- |
| dry_run | string İzin verilen değerler `true` | isteğe bağlı |

#### Gövde parametreleri

| Parametre | Tür | gerekli |
| --- | --- | --- |
| domains | string[] | gerekli |
| type | string İzin verilen değerler `A`, `AAAA`, `CNAME`, `MX`, `TXT`, `NS`, `SOA` Varsayılan `A` | isteğe bağlı |
| expected | string | isteğe bağlı |

#### Yanıt alanları

| Alan | Tür |
| --- | --- |
| `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 |

#### Örnek istek

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

	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/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"
})

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

#### Örnek yanıt

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

#### HTTP durum kodları

- `200` OK
- `400` Hatalı İstek
- `401` Yetkisiz
- `402` Ödeme Gerekli
- `409` HTTP 409
- `422` HTTP 422
- `429` Çok Fazla İstek
