API Reference

v1.0.0

The BarkScan API provides programmatic access to internet-wide scanning data, banner grabbing results, DNS records, and protocol analysis. All endpoints return JSON.

Base URL
https://barkscan.com/api/v1

Authentication

All API requests require authentication. You can authenticate using either a Bearer token header (recommended) or a query parameter.

API keys are managed from your account settings.

Bearer Token (Recommended)

Include your API key in the Authorization header.

Authorization: Bearer bsk_live_abc123...

Query Parameter

Append your API key as a query parameter.

GET /api/v1/search?api_key=bsk_live_abc123...

Code Examples

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://barkscan.com/api/v1/search?q=nginx"
import requests

resp = requests.get(
    "https://barkscan.com/api/v1/search?q=nginx",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = resp.json()
require "net/http"
require "json"

uri = URI("https://barkscan.com/api/v1/search?q=nginx")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)
const resp = await fetch("https://barkscan.com/api/v1/search?q=nginx", {
  headers: { "Authorization": "Bearer YOUR_API_KEY" }
});
const data = await resp.json();
Used for "Try it" requests below

Pagination

Endpoints that return lists support pagination via page and per_page query parameters. The maximum per_page value is 100 (default: 25).

Parameter Type Default Description
page integer 1 Page number (1-indexed, defaults to 1).
per_page integer 25 Results per page (1-100, defaults to 25).

Responses include a meta object with pagination info:

{
  "data": [
    "..."
  ],
  "meta": {
    "total": 1542,
    "page": 1,
    "per_page": 25
  }
}

Rate Limiting

API requests are subject to rate limiting. When rate-limited, you will receive a 429 Too Many Requests response. Monitor your usage with the following response headers:

Header Description
X-RateLimit-Limit Maximum number of requests allowed per rate limit window.
X-RateLimit-Remaining Number of requests remaining in the current window.
X-RateLimit-Reset UTC epoch timestamp (seconds) when the rate limit window resets.

Errors

The API uses standard HTTP status codes. All error responses include a JSON object with an error field containing a human-readable message.

Code Meaning
200 Success
400 Bad Request -- invalid parameters
401 Unauthorized -- missing or invalid API key
404 Not Found -- resource does not exist
429 Too Many Requests -- rate limit exceeded
500 Internal Server Error 
{
  "error": "Missing API key. Use Authorization: Bearer <key> header or ?api_key= parameter."
}
GET /search

Search public, recent PostgreSQL banner observations. This endpoint is not a complete historical endpoint inventory or a saved investigation. Historical browser investigations use POST /historical_searches on the site root and expose owned snapshot JSON/CSV routes.

q supports a typed Boolean expression with NOT > AND > OR precedence, parentheses, exact =, literal substring ~, and supported range operators. Text is case-insensitive unless =! or ~! is used. Regex and wildcard expansion are unsupported. Missing evidence remains unknown under NOT. Predicates match one observation, not combined facts from unrelated observations of the same host.

Fields include ip/CIDR, transport, port, protocol (alias service), status, source, banner, product, version, http.title, http.header.NAME, http.status, tls.name, tls.issuer, tls.fingerprint, tls.not_before, tls.expiry and tls.expired. Quote a whole field name if a header contains punctuation, for example "http.header.x~!y"="value". Version ranges require explicit supported product context (version.nginx, version.apache, version.openssh). tls.expired=true/false uses scan time; a timestamp selects that reference instant. HTTP numeric predicates use a shared IEEE-754 interpretation, requiring an integral value between 100 and 599; raw evidence is retained.

expression is the equivalent JSON tree, mutually exclusive with a nonempty q. Explicit filter controls are ANDed with the expression. Invalid syntax or unsupported fields return 400, never an unfiltered fallback. Smart shorthand for an IP/CIDR, port or banner remains accepted.

When q contains a domain name, the response returns an empty array with a hint to use the DNS endpoint instead.

Parameters

Name Type Required Description
q string No Typed Boolean query, up to 8192 UTF-8 bytes, 128 nodes and 16 levels. Examples: ip=203.0.113.1 AND port=443, (protocol=http OR protocol=tls) AND NOT http.title~"staging". Smart IP/CIDR and port shorthand remains supported.
expression No JSON representation of the same predicate, instead of nonempty q. At most 65536 encoded bytes; canonical query text must also fit 8192 bytes. A null root means no predicate.
ip string No Filter by an exact IPv4/IPv6 address or CIDR.
port integer No Filter by port number.
status string No Filter by result status (e.g. SUCCESS, TIMEOUT, REFUSED).
protocol string No Filter by detected protocol. ssh, http, tls
banner string No Substring search within banner text (case-insensitive).
start_date string No Only include results grabbed at or after this datetime (ISO 8601).
end_date string No Only include results grabbed at or before this datetime (ISO 8601).
page integer No Page number (1-indexed, defaults to 1).
per_page integer No Results per page (1-100, defaults to 25).

Response 200

{
  "data": [
    {
      "id": 918274650,
      "ip": "203.0.113.1",
      "port": 443,
      "status": "SUCCESS",
      "banner": "HTTP/1.1 200 OK\r\nServer: nginx/1.24.0\r\n...",
      "protocol_details": {
        "tls": {
          "version": "TLSv1.3",
          "cipher": "TLS_AES_256_GCM_SHA384"
        },
        "http": {
          "status_code": 200,
          "server": "nginx/1.24.0"
        }
      },
      "grabbed_at": "2026-02-20T14:30:00Z"
    }
  ],
  "meta": {
    "total": 1542,
    "page": 1,
    "per_page": 25
  }
}

Example Request

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://barkscan.com/api/v1/search?q=203.0.113.1&port=443&protocol=tls"
import requests

resp = requests.get(
    "https://barkscan.com/api/v1/search?q=203.0.113.1&port=443&protocol=tls",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = resp.json()
require "net/http"
require "json"

uri = URI("https://barkscan.com/api/v1/search?q=203.0.113.1&port=443&protocol=tls")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)
const resp = await fetch("https://barkscan.com/api/v1/search?q=203.0.113.1&port=443&protocol=tls", {
  headers: { "Authorization": "Bearer YOUR_API_KEY" }
});
const data = await resp.json();
Try it
GET /host/{ip}

Retrieve all recent banner grabbing results for a specific IP address, ordered by most recent first.

Parameters

Name Type Required Description
ip string Required IPv4 or IPv6 address.
page integer No Page number (1-indexed, defaults to 1).
per_page integer No Results per page (1-100, defaults to 25).

Response 200

{
  "data": [
    {
      "id": 918274650,
      "ip": "198.51.100.42",
      "port": 22,
      "status": "SUCCESS",
      "banner": "SSH-2.0-OpenSSH_9.6",
      "protocol_details": {
        "ssh": {
          "server_software": "OpenSSH_9.6",
          "kex_algorithms": [
            "curve25519-sha256",
            "diffie-hellman-group16-sha512"
          ],
          "host_key_algorithms": [
            "ssh-ed25519",
            "rsa-sha2-512"
          ]
        }
      },
      "grabbed_at": "2026-02-21T08:15:30Z"
    },
    {
      "id": 918274651,
      "ip": "198.51.100.42",
      "port": 80,
      "status": "SUCCESS",
      "banner": "HTTP/1.1 301 Moved Permanently\r\nLocation: https://example.com/\r\n...",
      "protocol_details": {
        "http": {
          "status_code": 301,
          "server": "nginx"
        }
      },
      "grabbed_at": "2026-02-21T08:15:31Z"
    }
  ],
  "meta": {
    "total": 2,
    "page": 1,
    "per_page": 25
  }
}

Example Request

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://barkscan.com/api/v1/host/198.51.100.42"
import requests

resp = requests.get(
    "https://barkscan.com/api/v1/host/198.51.100.42",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = resp.json()
require "net/http"
require "json"

uri = URI("https://barkscan.com/api/v1/host/198.51.100.42")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)
const resp = await fetch("https://barkscan.com/api/v1/host/198.51.100.42", {
  headers: { "Authorization": "Bearer YOUR_API_KEY" }
});
const data = await resp.json();
Try it
GET /host/{ip}/ports

Retrieve a sorted list of distinct port numbers observed for a specific IP address.

Parameters

Name Type Required Description
ip string Required IPv4 or IPv6 address.

Response 200

{
  "data": [
    22,
    80,
    443,
    3306,
    8080
  ],
  "meta": {}
}

Example Request

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://barkscan.com/api/v1/host/198.51.100.42/ports"
import requests

resp = requests.get(
    "https://barkscan.com/api/v1/host/198.51.100.42/ports",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = resp.json()
require "net/http"
require "json"

uri = URI("https://barkscan.com/api/v1/host/198.51.100.42/ports")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)
const resp = await fetch("https://barkscan.com/api/v1/host/198.51.100.42/ports", {
  headers: { "Authorization": "Bearer YOUR_API_KEY" }
});
const data = await resp.json();
Try it
GET /dns/{domain}

Query one pinned canonical DuckLake snapshot, without consulting a live resolver or a PostgreSQL DNS mirror. The default inventory groups all eligible observations by hostname before pagination. Other modes provide an exact-hostname timeline, observed-set comparison, last observation at a cutoff, nested-subtree inventory, retained-history discovery, or raw supporting evidence. Domain and subtree matching use whole DNS labels; the requested root is included.

Immutable observations retain complete answer sets, resolution timestamps and explicit resolved, nxdomain or no_records outcomes. Legacy merged addresses and record-creation times are labeled separately: they do not establish an answer at a historical instant. Missing observations are unknown, not evidence of disappearance or a negative DNS answer.

Every request uses admitted durable execution on an isolated DuckLake worker. A completed page, including an empty page, returns 200; queued, running, or canceling work returns 202 with a private status_url. Follow Location unchanged, including per_page, with the same requester credentials and respect Retry-After until ready. Polling does not submit another engine query.

Completed results include meta.snapshot and X-DNS-Snapshot. Retain that value and pass it as revision on subsequent pages, keeping domain, mode, time filters and per_page unchanged. Without revision, a new request can select a newer snapshot. total is null; use has_more or next_url rather than a full-dataset count. Saved query_usage describes the execution. Supporting evidence URLs submit separately admitted queries at the same snapshot; they do not silently expand the current saved page.

Parameters

Name Type Required Description
domain string Required Domain or subtree root, included along with whole-label descendants.
page integer No Page number (1-indexed, defaults to 1).
per_page integer No Results per page (1-100, defaults to 25).
revision string No Canonical snapshot returned in meta.snapshot or X-DNS-Snapshot. Reuse it with the same domain, mode, time filters and per_page for consistent pagination. Omit it to select a snapshot for a new execution. Only canonical ducklake:<snapshot_id> revisions are accepted; legacy archive inventory hashes are not page-continuation tokens. Malformed revisions return 400; unavailable snapshots fail execution rather than switching to newer data.
mode string No inventory groups hostnames in the requested period. timeline requires an exact hostname and annotates repeated or changed complete answers. compare uses periods A and B, never a difference between limited pages. as_of considers all retained observations at or before its cutoff, ignoring the display period and retaining conflicting equal-time answers. subtree includes the named root and all nested descendants. discovery filters each hostname's first known retained evidence, not its first occurrence inside the selected window. raw exposes evidence. inventory, timeline, compare, as_of, subtree, discovery, raw
hostname string No Exact hostname; required for timeline, optional for as_of and raw.
start_date string No Inclusive UTC lower bound for the observation period, period A, or discovery window. Omission is unbounded; as_of ignores this display bound.
end_date string No Inclusive UTC upper bound. Date-only values mean midnight, not the end of the day; RFC3339 timestamps retain their precision. Omission is unbounded.
compare_start_date string No Inclusive period B lower bound; required for compare.
compare_end_date string No Inclusive period B upper bound; required for compare.
as_of string No Inclusive UTC cutoff; required for as_of. Returns the last retained observation, not a claim that its answer remained current.

Response 200

{
  "data": [
    {
      "domain": "example.com",
      "hostname": "www.example.com",
      "ip": [
        "93.184.216.34"
      ],
      "first_observed_at": "2025-06-15T10:00:00Z",
      "last_observed_at": "2026-02-20T12:30:00Z",
      "observation_count": 12,
      "outcomes": [
        "resolved"
      ],
      "provenance": "immutable_dns",
      "answer_unknown": false
    }
  ],
  "meta": {
    "total": null,
    "page": 1,
    "per_page": 25,
    "has_more": false,
    "snapshot": "ducklake:42",
    "view": "inventory",
    "query_usage": {
      "engine": "ducklake",
      "queries": 1,
      "profiled_queries": 1,
      "read_bytes": 1048576,
      "remote_queries": 1,
      "remote_profile_read_bytes": 1048576,
      "cache_hits": 0,
      "cpu_seconds": 0.01,
      "query_seconds": 0.12,
      "executions": 1,
      "attempts": 1,
      "tracked_attempts": 1,
      "finalized_attempts": 1,
      "estimated_transfer_usd": 0.00001048576,
      "rate_min": 0.01,
      "rate_max": 0.01,
      "rate_basis": "configured_b2_download",
      "available": true,
      "partial": false
    }
  }
}

Response 202

{
  "data": {
    "state": "queued",
    "handle_id": "37bac764-d483-4dc8-9c2f-f63ee4ccd6cb",
    "status_url": "/api/v1/dns-searches/37bac764-d483-4dc8-9c2f-f63ee4ccd6cb?per_page=25"
  },
  "meta": {}
}

Example Request

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://barkscan.com/api/v1/dns/example.com"
import requests

resp = requests.get(
    "https://barkscan.com/api/v1/dns/example.com",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = resp.json()
require "net/http"
require "json"

uri = URI("https://barkscan.com/api/v1/dns/example.com")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)
const resp = await fetch("https://barkscan.com/api/v1/dns/example.com", {
  headers: { "Authorization": "Bearer YOUR_API_KEY" }
});
const data = await resp.json();
Try it
GET /dns/reverse/{ip}

Find canonical DNS history containing an exact IP address, combining the retained DuckLake baseline and immutable forward observations at one snapshot. Returns up to 100 records ordered by updated_at, without pagination. An empty result returns 200 with data: []. Negative observations have empty address arrays and do not match reverse queries. IPv4 and IPv6 are supported; a CIDR value matches an exact stored address/prefix, not every address within that network.

Every lookup uses admitted durable execution, with no PostgreSQL DNS fallback or live resolution. Queued/running/canceling work returns 202. Follow Location unchanged with the same requester credentials and respect Retry-After until ready. Completed results include meta.snapshot, X-DNS-Snapshot and query_usage. The optional revision selects a previously returned canonical snapshot instead of a new one.

Parameters

Name Type Required Description
ip string Required IPv4 or IPv6 address, or an exact CIDR value (URL-encode its slash).
revision string No Canonical snapshot returned in meta.snapshot or X-DNS-Snapshot. Reuse it with the same domain, mode, time filters and per_page for consistent pagination. Omit it to select a snapshot for a new execution. Only canonical ducklake:<snapshot_id> revisions are accepted; legacy archive inventory hashes are not page-continuation tokens. Malformed revisions return 400; unavailable snapshots fail execution rather than switching to newer data.

Response 200

{
  "data": [
    {
      "id": 47291830,
      "domain": "example.com",
      "tld": "example.com",
      "ip": [
        "93.184.216.34"
      ],
      "created_at": "2025-06-15T10:00:00Z",
      "updated_at": "2026-02-20T12:30:00Z",
      "provenance": "legacy_merged",
      "legacy": true,
      "answer_unknown": true
    },
    {
      "id": 47291831,
      "domain": "example.com",
      "tld": "www.example.com",
      "ip": [
        "93.184.216.34"
      ],
      "created_at": "2025-06-15T10:00:00Z",
      "updated_at": "2026-02-20T12:30:00Z",
      "provenance": "legacy_merged",
      "legacy": true,
      "answer_unknown": true
    }
  ],
  "meta": {
    "snapshot": "ducklake:42"
  }
}

Response 202

{
  "data": {
    "state": "queued",
    "handle_id": "37bac764-d483-4dc8-9c2f-f63ee4ccd6cb",
    "status_url": "/api/v1/dns-searches/37bac764-d483-4dc8-9c2f-f63ee4ccd6cb?per_page=25"
  },
  "meta": {}
}

Example Request

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://barkscan.com/api/v1/dns/reverse/93.184.216.34"
import requests

resp = requests.get(
    "https://barkscan.com/api/v1/dns/reverse/93.184.216.34",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = resp.json()
require "net/http"
require "json"

uri = URI("https://barkscan.com/api/v1/dns/reverse/93.184.216.34")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)
const resp = await fetch("https://barkscan.com/api/v1/dns/reverse/93.184.216.34", {
  headers: { "Authorization": "Bearer YOUR_API_KEY" }
});
const data = await resp.json();
Try it
GET /dns-searches/{id}

Read the state or saved payload of a durable DNS lookup without admitting or executing another engine query. Poll the original Location URL unchanged until ready, including its per_page value. Personal keys share their user's ownership; keys without a user are isolated by API key. Another requester receives 404, even when the handle exists.

On completion, retain meta.snapshot or X-DNS-Snapshot. Submit the next forward page to /dns/{domain} with that revision, mode, time filters and per_page; this polling URL is not a page-submission endpoint. Old payloads remain readable, but a legacy non-DuckLake revision cannot be used for consistent page continuation. Start a new canonical lookup in that case. Completed forward and reverse searches with no matches return 200 and an empty data array, including a forward page beyond the available results.

Parameters

Name Type Required Description
id string Required Private handle_id returned by the original DNS lookup.
per_page integer No Preserve the value in the original Location URL; changing it can change the saved page's presentation.

Response 202

{
  "data": {
    "state": "queued",
    "handle_id": "37bac764-d483-4dc8-9c2f-f63ee4ccd6cb",
    "status_url": "/api/v1/dns-searches/37bac764-d483-4dc8-9c2f-f63ee4ccd6cb?per_page=25"
  },
  "meta": {}
}

Example Request

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://barkscan.com/api/v1/dns-searches/37bac764-d483-4dc8-9c2f-f63ee4ccd6cb?per_page=25"
import requests

resp = requests.get(
    "https://barkscan.com/api/v1/dns-searches/37bac764-d483-4dc8-9c2f-f63ee4ccd6cb?per_page=25",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = resp.json()
require "net/http"
require "json"

uri = URI("https://barkscan.com/api/v1/dns-searches/37bac764-d483-4dc8-9c2f-f63ee4ccd6cb?per_page=25")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)
const resp = await fetch("https://barkscan.com/api/v1/dns-searches/37bac764-d483-4dc8-9c2f-f63ee4ccd6cb?per_page=25", {
  headers: { "Authorization": "Bearer YOUR_API_KEY" }
});
const data = await resp.json();
Try it
GET /stats/ports

Returns the count of banner results grouped by port number, sorted by count descending. By default, covers the last 24 hours.

Parameters

Name Type Required Description
since string No Only count results grabbed at or after this datetime (ISO 8601). Defaults to 24 hours ago.

Response 200

{
  "data": [
    {
      "port": 80,
      "count": 1842503
    },
    {
      "port": 443,
      "count": 1623871
    },
    {
      "port": 22,
      "count": 987432
    },
    {
      "port": 3306,
      "count": 234187
    },
    {
      "port": 8080,
      "count": 198432
    }
  ],
  "meta": {}
}

Example Request

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://barkscan.com/api/v1/stats/ports?since=2026-02-20T00:00:00Z"
import requests

resp = requests.get(
    "https://barkscan.com/api/v1/stats/ports?since=2026-02-20T00:00:00Z",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = resp.json()
require "net/http"
require "json"

uri = URI("https://barkscan.com/api/v1/stats/ports?since=2026-02-20T00:00:00Z")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)
const resp = await fetch("https://barkscan.com/api/v1/stats/ports?since=2026-02-20T00:00:00Z", {
  headers: { "Authorization": "Bearer YOUR_API_KEY" }
});
const data = await resp.json();
Try it
GET /stats/protocols

Returns the count of banner results by detected protocol (SSH, HTTP, TLS). By default, covers the last 24 hours.

Parameters

Name Type Required Description
since string No Only count results grabbed at or after this datetime (ISO 8601). Defaults to 24 hours ago.

Response 200

{
  "data": {
    "ssh": 987432,
    "http": 1842503,
    "tls": 1623871
  },
  "meta": {}
}

Example Request

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://barkscan.com/api/v1/stats/protocols"
import requests

resp = requests.get(
    "https://barkscan.com/api/v1/stats/protocols",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = resp.json()
require "net/http"
require "json"

uri = URI("https://barkscan.com/api/v1/stats/protocols")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)
const resp = await fetch("https://barkscan.com/api/v1/stats/protocols", {
  headers: { "Authorization": "Bearer YOUR_API_KEY" }
});
const data = await resp.json();
Try it
GET /account

Returns information about the authenticated user and the API key used for the request.

Parameters

This endpoint has no additional parameters beyond authentication.

Response 200

{
  "data": {
    "email": "[email protected]",
    "admin": false,
    "api_key": {
      "name": "Production Key",
      "created_at": "2025-11-01T09:00:00Z",
      "last_used_at": "2026-02-22T10:15:30Z"
    },
    "active_api_keys": 2
  },
  "meta": {}
}

Example Request

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://barkscan.com/api/v1/account"
import requests

resp = requests.get(
    "https://barkscan.com/api/v1/account",
    headers={"Authorization": "Bearer YOUR_API_KEY"}
)
data = resp.json()
require "net/http"
require "json"

uri = URI("https://barkscan.com/api/v1/account")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer YOUR_API_KEY"
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
data = JSON.parse(resp.body)
const resp = await fetch("https://barkscan.com/api/v1/account", {
  headers: { "Authorization": "Bearer YOUR_API_KEY" }
});
const data = await resp.json();
Try it

No parameters required. Uses your API key for authentication.

OpenAPI Specification

Download the full OpenAPI 3.0 specification for use with code generators, Postman, or other API tools.

Download openapi/v1.yaml

Ready to get started?

Create a free account and generate your API key in seconds.

Get API Key View API Solutions