> 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/pt/docs/check-availability

# Verificar Disponibilidade de Domínio

API da DomScan: Verifique se um nome de domínio está disponível em um ou mais TLDs.

Verifique se um nome de domínio está disponível em um ou mais TLDs.

GET /v1/status

#### Parâmetros de consulta

| Parâmetro | Tipo | Descrição |
| --- | --- | --- |
| name obrigatório | string | Etiqueta de domínio sem TLD (p.ex., |
| tlds obrigatório | string | Lista de TLDs separados por vírgula a verificar (máx. 50) |
| domain opcional | string | Domínio completo como mycompany.com, aceito em vez de name mais tlds. Será ignorado quando name e tlds forem fornecidos, e subdomínios serão rejeitados. |
| prefer_cache opcional | boolean token Valores permitidos `true`, `false`, `1`, `0`, `yes`, `no` | Utilize resultados em cache quando disponível (recomendado) |

#### Exemplo de requisição

```bash
curl -H "X-API-Key: your-api-key" "https://domscan.net/v1/status?name=startup&tlds=com,io,co&prefer_cache=1"
```

```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/status");
url.searchParams.set("name", "startup");
url.searchParams.set("tlds", "com,io,co");
url.searchParams.set("prefer_cache", "1");

const response = await domscanFetch(url);
const data = await response.json();
console.log(data.results);
```

```python
import requests

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

params = {"name": "startup", "tlds": "com,io,co", "prefer_cache": 1}
data = domscan.get("https://domscan.net/v1/status", params=params).json()
print(data["results"])
```

```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() {
  url := "https://domscan.net/v1/status?name=startup&tlds=com,io,co&prefer_cache=1"
  resp, _ := domscanGet(url)
  defer resp.Body.Close()

  var data map[string]any
  json.NewDecoder(resp.Body).Decode(&data)
  fmt.Println(data["results"])
}
```

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

uri = URI("https://domscan.net/v1/status?name=startup&tlds=com,io,co&prefer_cache=1")
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)
puts data["results"]
```

#### Exemplo de resposta

```json
{
                "name": "startup",
                "results": [
                {
                "domain": "startup.com",
                "tld": "com",
                "available": false,
                "source": "rdap",
                "checked_at": "2025-01-05T10:30:00.000Z"
                },
                {
                "domain": "startup.io",
                "tld": "io",
                "available": true,
                "source": "rdap",
                "checked_at": "2025-01-05T10:30:00.000Z"
                }
                ],
                "meta": {
                "served_by": "pop=LAX country=US"
                }
                }
```

#### Campos da resposta

| Campo | Tipo |
| --- | --- |
| `cache_age_s` | integer |
| `name` | string |
| `results[]` | object[] |
| `results[]` | object |
| `results[].classification` | object |
| `results[].classification.status` | string |
| `results[].classification.reason` | string |
| `results[].classification.evidence` | object |
| `results[].classification.evidence.source` | string |
| `results[].classification.evidence.method` | string |
| `results[].classification.evidence.observed_at` | string |
| `results[].classification.evidence.detail` | string |
| `results[].classification.checked_at` | string |
| `results[].domain` | string |
| `results[].tld` | string |
| `results[].available` | boolean \| null |
| `results[].availability_reason` | string |
| `results[].source` | string |
| `results[].confidence` | string |
| `results[].checked_at` | string |
| `results[].latency_ms` | integer |
| `results[].cache_age_s` | integer |
| `results[].registry_status[]` | string[] |
| `results[].rdap_events[]` | object[] |
| `results[].rdap_events[]` | object |
| `results[].rdap_events[].eventAction` | string |
| `results[].rdap_events[].eventDate` | string |
| `results[].proof` | object |
| `results[].dns_status` | object |
| `results[].dns_status.has_nameservers` | boolean |
| `results[].dns_status.resolvable` | boolean |
| `results[].dns_status.checked` | boolean |
| `results[].timing` | object |
| `results[].timing.cache_lookup_ms` | integer |
| `results[].timing.rdap_query_ms` | integer |
| `results[].timing.dns_check_ms` | integer |
| `results[].timing.total_ms` | integer |
| `results[].status_flags[]` | string[] |
| `results[].status` | string |
| `results[].lifecycle_phase` | string |
| `results[].is_public_suffix` | boolean |
| `results[].error` | object |
| `results[].error.code` | string |
| `results[].error.message` | string |
| `results[].error.suggestion` | string |
| `results[].error.cause` | string |
| `scope` | string |
| `confidence_summary` | object |
| `confidence_summary.scope` | string |
| `confidence_summary.requested_count` | integer |
| `confidence_summary.result_count` | integer |
| `confidence_summary.invalid_count` | integer |
| `confidence_summary.available_count` | integer |
| `confidence_summary.registered_count` | integer |
| `confidence_summary.restricted_count` | integer |
| `confidence_summary.authoritative_count` | integer |
| `confidence_summary.heuristic_count` | integer |
| `confidence_summary.cached_count` | integer |
| `confidence_summary.error_count` | integer |
| `confidence_summary.ambiguous_count` | integer |
| `confidence_summary.source_counts` | object |
| `confidence_summary.primary_source` | string \| null |
| `confidence_summary.cache_status` | string |
| `confidence_summary.rdap_calls` | integer |
| `confidence_summary.refreshes` | integer |
| `confidence_summary.cache_preference_misses` | integer |
| `confidence_summary.fallback_chain[]` | string[] |
| `confidence_summary.confidence_level` | string |
| `confidence_summary.determinacy_rate` | number |
| `confidence_summary.ambiguity_reason` | string \| null |
| `meta` | object |
| `meta.total_checked` | integer |
| `meta.available_count` | integer |
| `meta.duration_ms` | integer |
| `meta.served_by` | string |
| `meta.scope_description` | string |