Dokumentacja dla deweloperów

Dostępność nazwy w mediach społecznościowych

DomScan API do analizy domen: Sprawdź dostępność nazwy użytkownika na głównych platformach mediów społecznych.

Dostępność nazwy w mediach społecznościowych

Sprawdź dostępność nazwy użytkownika na głównych platformach mediów społecznych.

GET /v1/social

Parametry zapytania

ParametrTypOpis
handle wymagane string Nazwa użytkownika lub identyfikator do sprawdzenia
platforms string Lista platform do sprawdzenia, oddzielona przecinkami (domyslnie: wszystkie obslugiwane platformy)
resources string Opcjonalne typy zasobów rozdzielone przecinkami. Jeśli nie podano platform, sprawdzane są tylko te zasoby.

Przykładowa odpowiedź

{
                "handle": "mycompany",
                "availability": {
                "github": { "available": false, "profile_url": "https://github.com/mycompany", "checked": true, "requested": true, "method": "official_api", "confidence": "high" },
                "reddit": { "available": true, "profile_url": null, "checked": true, "requested": true, "method": "public_endpoint", "confidence": "high" },
                "youtube": { "available": true, "profile_url": null, "checked": true, "requested": true, "method": "public_profile", "confidence": "high" }
                },
                "resources": {},
                "resource_summary": {
                "requested_count": 0,
                "checked_count": 0,
                "present_count": 0,
                "absent_count": 0,
                "unknown_count": 0,
                "cached_count": 0,
                "determinacy_rate": 0
                },
                "summary": {
                "available_count": 2,
                "unavailable_count": 1,
                "unknown_count": 0
                },
                "summary_v2": {
                "requested_count": 3,
                "checked_count": 3,
                "available_count": 2,
                "unavailable_count": 1,
                "unknown_count": 0,
                "not_supported_count": 0,
                "determinacy_rate": 1
                }
                }

Pola odpowiedzi

Pole Typ
handle string
checked_at string
availability object
resources object
resource_summary object
resource_summary.requested_count integer
resource_summary.checked_count integer
resource_summary.present_count integer
resource_summary.absent_count integer
resource_summary.unknown_count integer
resource_summary.cached_count integer
resource_summary.determinacy_rate number
summary object
summary.available_count integer
summary.unavailable_count integer
summary.unknown_count integer
summary_v2 object
summary_v2.requested_count integer
summary_v2.checked_count integer
summary_v2.available_count integer
summary_v2.unavailable_count integer
summary_v2.unknown_count integer
summary_v2.not_supported_count integer
summary_v2.determinacy_rate number
platform_summary object
platform_summary.requested_count integer
platform_summary.checked_count integer
platform_summary.available_count integer
platform_summary.unavailable_count integer
platform_summary.unknown_count integer
platform_summary.not_supported_count integer
platform_summary.cached_count integer
platform_summary.high_confidence_count integer
platform_summary.live_platform_count integer
platform_summary.experimental_count integer
platform_summary.blocked_count integer
platform_summary.beta_limited_count integer
platform_summary.determinacy_rate number
platform_summary.method_counts object
platform_summary.source_counts object
beta_notice string
meta object
meta.served_by string
meta.supported_platforms[] string[]
meta.supported_resources[] string[]
meta.unsupported_platforms[] string[]
meta.latency_ms integer
Zasoby platform

Sprawdzaj tożsamości o określonym zakresie, takie jak repozytoria, subreddity, zaproszenia Discord, profile Substack i konta federacyjne, bez zmiany punktów końcowych.

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/social?handle=github%2Fdocs&resources=github%3Arepository"
Zbiorcze sprawdzanie nazw użytkowników w mediach społecznościowych

Tak. Prześlij do 10 nazw użytkowników przez POST /v1/social/bulk, opcjonalnie z listą platform. W przypadku sprawdzania zbiorczego obowiązuje taka sama stawka kredytów za każdą nazwę użytkownika jak przy sprawdzaniu pojedynczym.

curl -X POST "https://domscan.net/v1/social/bulk" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"handles":["mycompany","myproduct"],"platforms":["github","reddit","youtube"]}'
POST /v1/social/bulk Kredyty: 2/item

Parametry zapytania

Parametr Typ wymagane
dry_run string
Dozwolone wartości true
opcjonalne

Parametry treści

Parametr Typ wymagane
handles string[] wymagane
platforms string[] opcjonalne
resources string[] opcjonalne

Pola odpowiedzi

Pole Typ
results[] unknown[]
summary object
summary.total integer
summary.succeeded integer
summary.failed integer
beta_notice string
meta object
meta.served_by string
meta.platforms[] string[]
meta.resources[] string[]
meta.max_handles integer
meta.credits_per_handle integer
meta.credits_required integer
meta.latency_ms integer

Przykładowe żądanie

curl -X POST "https://domscan.net/v1/social/bulk" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "handles": [
    "mycompany",
    "myproduct"
  ],
  "platforms": [
    "github",
    "reddit",
    "youtube"
  ]
}'
const response = await fetch("https://domscan.net/v1/social/bulk", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "handles": [
      "mycompany",
      "myproduct"
    ],
    "platforms": [
      "github",
      "reddit",
      "youtube"
    ]
  }),
});
const data = await response.json();
console.log(data);
import os
import requests

response = requests.post(
    "https://domscan.net/v1/social/bulk",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "handles": [
            "mycompany",
            "myproduct",
        ],
        "platforms": [
            "github",
            "reddit",
            "youtube",
        ],
    },
)
print(response.json())
package main

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

func main() {
	body := strings.NewReader(`{
	  "handles": [
	    "mycompany",
	    "myproduct"
	  ],
	  "platforms": [
	    "github",
	    "reddit",
	    "youtube"
	  ]
	}`)
	req, err := http.NewRequest(http.MethodPost, "https://domscan.net/v1/social/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))
}
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/social/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({
  "handles" => [
    "mycompany",
    "myproduct"
  ],
  "platforms" => [
    "github",
    "reddit",
    "youtube"
  ]
})

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

Przykładowa odpowiedź

{
  "results": [
    {
      "handle": "mycompany",
      "availability": {
        "github": {
          "available": false,
          "profile_url": "https://github.com/mycompany",
          "checked": true,
          "requested": true,
          "method": "official_api",
          "confidence": "high"
        }
      },
      "resources": {},
      "resource_summary": {
        "requested_count": 0,
        "checked_count": 0,
        "present_count": 0,
        "absent_count": 0,
        "unknown_count": 0,
        "cached_count": 0,
        "determinacy_rate": 0
      },
      "summary": {
        "available_count": 0,
        "unavailable_count": 1,
        "unknown_count": 0
      },
      "checked_at": "2026-07-09T20:45:00.000Z"
    },
    {
      "handle": "myproduct",
      "availability": {
        "github": {
          "available": true,
          "profile_url": null,
          "checked": true,
          "requested": true,
          "method": "official_api",
          "confidence": "high"
        }
      },
      "resources": {},
      "resource_summary": {
        "requested_count": 0,
        "checked_count": 0,
        "present_count": 0,
        "absent_count": 0,
        "unknown_count": 0,
        "cached_count": 0,
        "determinacy_rate": 0
      },
      "summary": {
        "available_count": 1,
        "unavailable_count": 0,
        "unknown_count": 0
      },
      "checked_at": "2026-07-09T20:45:00.000Z"
    }
  ],
  "summary": {
    "total": 2,
    "succeeded": 2,
    "failed": 0
  },
  "beta_notice": "Social handle checks are in beta; verify critical results directly.",
  "meta": {
    "served_by": "pop=MAD country=ES",
    "platforms": [
      "github"
    ],
    "resources": [],
    "max_handles": 10,
    "credits_per_handle": 2,
    "credits_required": 4,
    "latency_ms": 420
  }
}

Kody statusu HTTP

  • 200 OK
  • 400 Nieprawidłowe żądanie
  • 401 Nieautoryzowany
  • 402 Wymagana płatność
  • 409 HTTP 409
  • 422 HTTP 422
  • 429 Zbyt wiele żądań
GET /v1/social/info Kredyty: 0

Pola odpowiedzi

Pole Typ
endpoint string
description string
parameters object
bulk object
bulk.endpoint string
bulk.method string
bulk.max_handles integer
bulk.credits_per_handle integer
bulk.pricing_formula string
bulk.bulk_discount boolean
bulk.invalid_handles_charged boolean
bulk.partial_results boolean
bulk.parameters object
bulk.example_request object
platforms object
platforms.supported[] string[]
platforms.coming_soon[] string[]
platforms.experimental[] string[]
platforms.planned[] string[]
platforms.blocked[] string[]
platforms.details[] object[]
platforms.details[] object
platforms.details[].id string
platforms.details[].display_name string
platforms.details[].aliases[] string[]
platforms.details[].category string
platforms.details[].tier integer
platforms.details[].status string
platforms.details[].method string
platforms.details[].confidence string
platforms.details[].logo_key string
platforms.details[].profile_url_template string | null
platforms.details[].docs_anchor string
platforms.details[].caveat_codes[] string[]
platforms.details[].cache_ttl_s object
platforms.details[].cache_ttl_s.available integer
platforms.details[].cache_ttl_s.taken integer
platforms.details[].cache_ttl_s.unknown integer
platforms.details[].cache_ttl_s.rate_limited integer
platforms.details[].handle_rules object
platforms.details[].handle_rules.min_length integer
platforms.details[].handle_rules.max_length integer
platforms.details[].handle_rules.description string
resource_types object
resource_types.supported[] string[]
resource_types.details[] object[]
resource_types.details[] object
example_request string
resource_example_request string
example_response object

Przykładowe żądanie

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/social/info"
const response = await fetch("https://domscan.net/v1/social/info", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
import os
import requests

response = requests.get(
    "https://domscan.net/v1/social/info",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
package main

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

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/social/info", 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))
}
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/social/info")
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))

Przykładowa odpowiedź

{
  "endpoint": "/v1/social",
  "description": "Check if a username is available on supported social platforms.",
  "parameters": {
    "handle": {
      "type": "string",
      "required": true,
      "description": "Username to check"
    },
    "platforms": {
      "type": "string",
      "required": false,
      "description": "Comma-separated platform list",
      "example": "github,gitlab,reddit"
    },
    "resources": {
      "type": "string",
      "required": false,
      "description": "Comma-separated resource type list",
      "example": "github:repository"
    }
  },
  "bulk": {
    "endpoint": "/v1/social/bulk",
    "method": "POST",
    "max_handles": 10,
    "credits_per_handle": 2,
    "pricing_formula": "valid_handle_count * credits_per_handle",
    "bulk_discount": false,
    "invalid_handles_charged": false,
    "partial_results": true,
    "parameters": {
      "handles": {
        "type": "array",
        "required": true,
        "min_items": 1,
        "max_items": 10
      },
      "platforms": {
        "type": "array",
        "required": false
      },
      "resources": {
        "type": "array",
        "required": false
      }
    },
    "example_request": {
      "handles": [
        "mycompany",
        "myproduct"
      ],
      "platforms": [
        "github",
        "reddit",
        "youtube"
      ]
    }
  },
  "platforms": {
    "supported": [
      "github",
      "gitlab",
      "bitbucket",
      "devto",
      "huggingface",
      "dribbble",
      "soundcloud",
      "gumroad",
      "buymeacoffee",
      "substack",
      "itchio",
      "behance",
      "dockerhub",
      "hashnode",
      "rubygems",
      "hackernews",
      "reddit",
      "bluesky",
      "twitter",
      "instagram",
      "facebook",
      "threads",
      "pinterest",
      "snapchat",
      "telegram",
      "twitch",
      "patreon",
      "tiktok",
      "youtube",
      "linkedin",
      "steam",
      "tumblr",
      "vimeo",
      "letterboxd",
      "linktree",
      "kick",
      "medium",
      "mastodon",
      "roblox",
      "minecraft",
      "chesscom",
      "lichess",
      "npm",
      "discord",
      "keybase",
      "codeforces",
      "gitee",
      "lemmy",
      "farcaster",
      "opencollective"
    ],
    "coming_soon": [],
    "experimental": [],
    "planned": [],
    "blocked": [],
    "details": [
      {
        "id": "github",
        "display_name": "GitHub",
        "aliases": [
          "github"
        ],
        "category": "developer",
        "tier": 0,
        "status": "live",
        "method": "official_api",
        "confidence": "high",
        "logo_key": "github",
        "profile_url_template": "https://github.com/{handle}",
        "docs_anchor": "github",
        "caveat_codes": [],
        "cache_ttl_s": {
          "available": 300,
          "taken": 3600,
          "unknown": 60,
          "rate_limited": 60
        },
        "handle_rules": {
          "min_length": 1,
          "max_length": 39,
          "description": "1-39 chars, alphanumeric and hyphens, cannot start/end with hyphen"
        }
      }
    ]
  },
  "resource_types": {
    "supported": [
      "reddit:subreddit",
      "discord:invite",
      "github:repository",
      "gitlab:project",
      "dockerhub:repository",
      "activitypub:account",
      "substack:profile"
    ]
  },
  "example_request": "/v1/social?handle=myusername&platforms=github,gitlab,reddit",
  "resource_example_request": "/v1/social?handle=github/docs&resources=github:repository",
  "example_response": {
    "handle": "myusername",
    "checked_at": "2026-07-14T12:00:00Z",
    "availability": {
      "github": {
        "available": true,
        "profile_url": null,
        "checked": true,
        "requested": true
      },
      "reddit": {
        "available": false,
        "profile_url": "https://reddit.com/user/myusername",
        "checked": true,
        "requested": true
      },
      "gitlab": {
        "available": true,
        "profile_url": null,
        "checked": true,
        "requested": true
      }
    },
    "resources": {},
    "resource_summary": {
      "requested_count": 0,
      "checked_count": 0,
      "present_count": 0,
      "absent_count": 0,
      "unknown_count": 0,
      "cached_count": 0,
      "determinacy_rate": 0
    },
    "summary": {
      "available_count": 2,
      "unavailable_count": 1,
      "unknown_count": 0
    },
    "summary_v2": {
      "requested_count": 3,
      "checked_count": 3,
      "available_count": 2,
      "unavailable_count": 1,
      "unknown_count": 0,
      "not_supported_count": 0,
      "determinacy_rate": 1
    }
  }
}

Kody statusu HTTP

  • 200 OK
  • 401 Nieautoryzowany
  • 429 Zbyt wiele żądań
GET /v1/name-check Kredyty: 5

Parametry zapytania

Parametr Typ wymagane
name string wymagane
tlds string opcjonalne
platforms string opcjonalne
packages string opcjonalne

Pola odpowiedzi

Pole Typ
name string
status string
checked_at string
verdict string
score integer | null
determinacy integer
summary object
summary.com_available boolean | null
summary.domains object
summary.domains.checked integer
summary.domains.free integer
summary.domains.taken integer
summary.domains.unknown integer
summary.handles object
summary.handles.checked integer
summary.handles.free integer
summary.handles.taken integer
summary.handles.unknown integer
summary.packages object
summary.packages.checked integer
summary.packages.free integer
summary.packages.taken integer
summary.packages.unknown integer
domains[] object[]
domains[] object
domains[].domain string
domains[].tld string
domains[].status string
domains[].reason string | null
handles[] object[]
handles[] object
handles[].platform string
handles[].status string
handles[].url string | null
handles[].reason string | null
packages[] object[]
packages[] object
packages[].registry string
packages[].name string
packages[].status string
packages[].url string | null
packages[].reason string | null
meta object
meta.duration_ms integer

Przykładowe żądanie

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/name-check?name=acmeflow&tlds=com%2Cio%2Cai&platforms=github%2Cinstagram%2Ctiktok&packages=npm%2Cpypi"
const response = await fetch("https://domscan.net/v1/name-check?name=acmeflow&tlds=com%2Cio%2Cai&platforms=github%2Cinstagram%2Ctiktok&packages=npm%2Cpypi", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
import os
import requests

response = requests.get(
    "https://domscan.net/v1/name-check?name=acmeflow&tlds=com%2Cio%2Cai&platforms=github%2Cinstagram%2Ctiktok&packages=npm%2Cpypi",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
package main

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

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/name-check?name=acmeflow&tlds=com%2Cio%2Cai&platforms=github%2Cinstagram%2Ctiktok&packages=npm%2Cpypi", 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))
}
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/name-check?name=acmeflow&tlds=com%2Cio%2Cai&platforms=github%2Cinstagram%2Ctiktok&packages=npm%2Cpypi")
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))

Przykładowa odpowiedź

{
  "name": "acmeflow",
  "status": "ok",
  "checked_at": "2026-10-13T18:00:00.000Z",
  "verdict": "mostly_available",
  "score": 80,
  "determinacy": 100,
  "summary": {
    "com_available": false,
    "domains": {
      "checked": 2,
      "free": 1,
      "taken": 1,
      "unknown": 0
    },
    "handles": {
      "checked": 2,
      "free": 2,
      "taken": 0,
      "unknown": 0
    },
    "packages": {
      "checked": 1,
      "free": 1,
      "taken": 0,
      "unknown": 0
    }
  },
  "domains": [
    {
      "domain": "acmeflow.com",
      "tld": "com",
      "status": "taken",
      "reason": null
    },
    {
      "domain": "acmeflow.io",
      "tld": "io",
      "status": "available",
      "reason": null
    }
  ],
  "handles": [
    {
      "platform": "github",
      "status": "available",
      "url": null,
      "reason": null
    },
    {
      "platform": "instagram",
      "status": "available",
      "url": null,
      "reason": null
    }
  ],
  "packages": [
    {
      "registry": "npm",
      "name": "acmeflow",
      "status": "not_found",
      "url": null,
      "reason": "similar_name_rules"
    }
  ],
  "meta": {
    "duration_ms": 4210
  }
}

Kody statusu HTTP

  • 200 OK
  • 400 Nieprawidłowe żądanie
  • 401 Nieautoryzowany
  • 402 Wymagana płatność
  • 429 Zbyt wiele żądań
GET /v1/avatar Kredyty: 2

Parametry zapytania

Parametr Typ wymagane
email string opcjonalne
username string opcjonalne
platform string
Dozwolone wartości githubblueskymastodonkeybase
opcjonalne
domain string opcjonalne

Pola odpowiedzi

Pole Typ
cache_age_s integer
input object
input.type string
input.value string
input.platform string | null
avatar object
avatar.url string
avatar.source string
avatar.kind string
avatar.verified boolean
avatar.content_type string | null
avatar.width integer
avatar.height integer
avatar.profile_url string | null
candidates[] object[]
candidates[] object
candidates[].source string
candidates[].kind string
candidates[].status string
candidates[].reason string
candidates[].detail string
candidates[].url string | null
candidates[].verified boolean
candidates[].content_type string | null
candidates[].width integer
candidates[].height integer
candidates[].profile_url string | null
candidates[].may_be_generated boolean
status string
classification object
classification.status string
classification.reason string
classification.evidence object
classification.evidence.source string
classification.evidence.method string
classification.evidence.observed_at string
classification.evidence.detail string
classification.checked_at string
checked_at string
meta object
meta.cached boolean
meta.sources_checked integer

Przykładowe żądanie

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/avatar?email=user%40example.com&username=example&platform=github&domain=example.com"
const response = await fetch("https://domscan.net/v1/avatar?email=user%40example.com&username=example&platform=github&domain=example.com", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);
import os
import requests

response = requests.get(
    "https://domscan.net/v1/avatar?email=user%40example.com&username=example&platform=github&domain=example.com",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())
package main

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

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/avatar?email=user%40example.com&username=example&platform=github&domain=example.com", 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))
}
require "json"
require "net/http"

uri = URI("https://domscan.net/v1/avatar?email=user%40example.com&username=example&platform=github&domain=example.com")
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))

Przykładowa odpowiedź

{
  "input": {
    "type": "username",
    "value": "octocat",
    "platform": null
  },
  "avatar": {
    "url": "https://cdn.bsky.app/img/avatar/plain/did:plc:example/bafkreiexample",
    "source": "bluesky",
    "kind": "avatar",
    "verified": true,
    "content_type": "image/jpeg",
    "profile_url": "https://bsky.app/profile/octocat.bsky.social"
  },
  "candidates": [
    {
      "source": "github",
      "kind": "avatar",
      "status": "present",
      "detail": "image_verified",
      "url": "https://avatars.githubusercontent.com/u/583231?v=4",
      "verified": true,
      "content_type": "image/png",
      "profile_url": "https://github.com/octocat",
      "may_be_generated": true
    },
    {
      "source": "bluesky",
      "kind": "avatar",
      "status": "present",
      "detail": "image_verified",
      "url": "https://cdn.bsky.app/img/avatar/plain/did:plc:example/bafkreiexample",
      "verified": true,
      "content_type": "image/jpeg",
      "profile_url": "https://bsky.app/profile/octocat.bsky.social"
    },
    {
      "source": "mastodon",
      "kind": "avatar",
      "status": "absent",
      "detail": "account_not_found",
      "url": null,
      "verified": false,
      "content_type": null
    },
    {
      "source": "keybase",
      "kind": "avatar",
      "status": "unknown",
      "reason": "rate_limited",
      "detail": "http_429",
      "url": null,
      "verified": false,
      "content_type": null
    }
  ],
  "status": "present",
  "classification": {
    "status": "present",
    "evidence": {
      "source": "bluesky",
      "method": "image_probe",
      "observed_at": "2026-11-02T10:00:00.000Z",
      "detail": "image_verified"
    },
    "checked_at": "2026-11-02T10:00:00.000Z"
  },
  "checked_at": "2026-11-02T10:00:00.000Z",
  "meta": {
    "cached": false,
    "sources_checked": 4
  }
}

Kody statusu HTTP

  • 200 OK
  • 400 Nieprawidłowe żądanie
  • 401 Nieautoryzowany
  • 402 Wymagana płatność
  • 429 Zbyt wiele żądań