Kaspa answers in your own app

Quick start

1. Get an accountThe lab owner opens accounts, each with a name and the email its holder signs in with. To ask for one, write to [email protected].
2. Sign in to your dashboardAt lab-dashboard.kaspa.news, with that email. You get a one-time code by email.
3. Add money, if your account is prepaidIn Billing, top up with KAS. Card payments are coming. If the lab pays for your account, Billing says so and you skip this step.
4. Make a keyIn Keys. Copy it at once: it is shown only once. Keep it on your server, for example in an environment variable named KASPA_LAB_KEY.
5. Ask your first questionCopy the curl, JavaScript or Python example below and run it.

curl https://lab-api.kaspa.news/v1/ask \
  -H "Authorization: Bearer $KASPA_LAB_KEY" \
  -H "Content-Type: application/json" \
  -d '{"question": "What is GHOSTDAG?"}'

// ask.mjs, for Node 18 or newer: node ask.mjs
const res = await fetch('https://lab-api.kaspa.news/v1/ask', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.KASPA_LAB_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ question: 'What is GHOSTDAG?' }),
});
const data = await res.json();
if (!res.ok) throw new Error(`${data.code}: ${data.error}`);
console.log(data.answer);
console.log(`Price: $${data.price_usd} (request ${data.id})`);

# ask.py: pip install requests, then python ask.py
import os

import requests

res = requests.post(
    'https://lab-api.kaspa.news/v1/ask',
    headers={'Authorization': f"Bearer {os.environ['KASPA_LAB_KEY']}"},
    json={'question': 'What is GHOSTDAG?'},
    timeout=180,
)
data = res.json()
if not res.ok:
    raise SystemExit(f"{data['code']}: {data['error']}")
print(data['answer'])
print(f"Price: ${data['price_usd']} (request {data['id']})")

The answer comes back as JSON (the id and price here are examples):

{
  "id": "req_9f2c4e1a7b3d5c60",
  "answer": "**GHOSTDAG** is the rule Kaspa nodes use to put all blocks into one agreed order, including blocks that were made at the same time. Blocks made in parallel are kept instead of thrown away, which lets Kaspa make many blocks every second.",
  "price_usd": 0.0251
}

Next: show the words as they are written, ask follow-up questions, or add the chat box to your website.

Authentication

Send your key in the Authorization header of every request:

POST /v1/ask HTTP/1.1
Host: lab-api.kaspa.news
Authorization: Bearer klab_...
Content-Type: application/json

{"question": "What is GHOSTDAG?"}

• A key is klab_ and 43 more letters, digits, - or _.
• It is shown once, when you make it. The lab keeps only a fingerprint of it, so a lost key cannot be shown again: make a new one.
• All keys of an account share its limits and its bill. An account can have up to 10 active keys; give each one a name of up to 60 characters, such as the app that uses it.
• Keys in your dashboard show their first 12 and last 4 characters, when they were made and when they were last used.

Rotate and revoke

Revoke stops a key at once: its next request gets 401 invalid_key. Rotate makes a new key with the same name and stops the old one at the same moment. To change keys with no gap, make a second key, put it on your server, then revoke the old one. If a key leaks, revoke it in Keys straight away.

POST /v1/ask

Ask one question about Kaspa. The body is one JSON object of at most 128,000 bytes, sent with a Content-Length header (every common HTTP client does this for you).

Request body

Only true turns stream and simple on. Fields the lab does not know are ignored.

{
  "question": "How is DAGKnight different?",
  "history": [
    {
      "q": "What is GHOSTDAG?",
      "a": "GHOSTDAG is the rule Kaspa nodes use to put all blocks into one agreed order, including blocks that were made at the same time."
    }
  ],
  "stream": false,
  "simple": false
}

Response

200 with a JSON object of exactly these three fields:

Checked code and dates

When an answer has code or a Unix timestamp in milliseconds, the lab checks it before you get it, as the chat on lab.kaspa.news does:

• Every SilverScript contract is compiled with silverc 1.0.0. One that does not compile is fixed automatically when that works, and the answer then carries the fixed contract.
• Python that uses the Kaspa SDK is checked against the SDK's real names, arguments and fields, and fixed the same way.
• Every timestamp is turned back into its date, so a wrong date is caught.
• A contract you paste into your question is compiled too, exactly as you wrote it, and its result comes first.

The results follow the answer as a short Checks list. An answer without code or timestamps has no such list.

...the end of the answer.

**Checks**
- Contract `Vault` compiles with silverc 1.0.0.
- The Python code uses only names, arguments and fields that exist in kaspa 2.1.0.
- `1798761600000` = 1 January 2027 00:00 UTC.

Kinds of answers

{
  "id": "req_95fea651e10a6010",
  "answer": "I only answer questions about Kaspa. Ask me anything about Kaspa: how it works, wallets, mining or building on it.",
  "price_usd": 0.0
}

How long an answer takes

Fixed lines and live numbers come straight away. An answer the lab writes takes longer, and a long, detailed answer longer still. Give your HTTP client a generous timeout (the examples here use 180 seconds), or stream: the words show as they are written, and the lab sends a keep-alive line about every 15 seconds while it works.

Streaming

Add "stream": true to show the answer while it is written. The response is 200 with Content-Type: text/event-stream (server-sent events).

Events

Each event is an event: line, a data: line with JSON, and an empty line.

Lines that start with a colon, such as : still working, keep the connection open while the lab works. Skip them, and skip any event name you do not know.

event: token
data: "GHOSTDAG is the rule Kaspa nodes use"

event: token
data: " to put all blocks into one agreed order"

: still working

event: token
data: ", including blocks made at the sa"

event: done
data: {"id": "req_9f2c4e1a7b3d5c60", "answer": "GHOSTDAG is the rule Kaspa nodes use to put all blocks into one agreed order, including blocks made at the same time.", "price_usd": 0.0251}

Read the stream with curl, JavaScript or Python

curl -N https://lab-api.kaspa.news/v1/ask \
  -H "Authorization: Bearer $KASPA_LAB_KEY" \
  -H "Content-Type: application/json" \
  -d '{"question": "How fast is Kaspa?", "stream": true}'

// stream.mjs, for Node 18 or newer: node stream.mjs
const res = await fetch('https://lab-api.kaspa.news/v1/ask', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.KASPA_LAB_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ question: 'How fast is Kaspa?', stream: true }),
});
if (!res.ok) {
  // refused before the answer started: a normal JSON error
  const error = await res.json();
  throw new Error(`${error.code}: ${error.error}`);
}
const decoder = new TextDecoder();
let buffer = '';
let shown = '';
for await (const chunk of res.body) {
  buffer += decoder.decode(chunk, { stream: true });
  let end;
  while ((end = buffer.indexOf('\n\n')) >= 0) {
    // one event ends with an empty line
    const block = buffer.slice(0, end);
    buffer = buffer.slice(end + 2);
    const event = block.match(/^event: (.*)$/m)?.[1];
    const data = block.match(/^data: (.*)$/m)?.[1];
    if (!event || data === undefined) continue; // a ": still working" line
    if (event === 'token') {
      const piece = JSON.parse(data);
      shown += piece;
      process.stdout.write(piece);
    } else if (event === 'done') {
      // the complete, checked answer: finish the text from it
      const { answer, price_usd, id } = JSON.parse(data);
      const same = answer.startsWith(shown);
      console.log(same ? answer.slice(shown.length) : `\n\n${answer}`);
      console.log(`\nPrice: $${price_usd} (request ${id})`);
    } else if (event === 'error') {
      const failure = JSON.parse(data);
      throw new Error(`${failure.code}: ${failure.message}`);
    }
  }
}

# stream.py: pip install requests, then python stream.py
import json
import os

import requests

res = requests.post(
    'https://lab-api.kaspa.news/v1/ask',
    headers={'Authorization': f"Bearer {os.environ['KASPA_LAB_KEY']}"},
    json={'question': 'How fast is Kaspa?', 'stream': True},
    stream=True,
    timeout=180,
)
if not res.ok:
    # refused before the answer started: a normal JSON error
    error = res.json()
    raise SystemExit(f"{error['code']}: {error['error']}")
event, shown = None, ''
for line in res.iter_lines(decode_unicode=True):
    if line.startswith('event: '):
        event = line[len('event: '):]
    elif line.startswith('data: ') and event:
        data = json.loads(line[len('data: '):])
        if event == 'token':
            shown += data
            print(data, end='', flush=True)
        elif event == 'done':
            # the complete, checked answer: finish the text from it
            answer = data['answer']
            same = answer.startswith(shown)
            print(answer[len(shown):] if same else '\n\n' + answer)
            print(f"\nPrice: ${data['price_usd']} (request {data['id']})")
        elif event == 'error':
            raise SystemExit(f"{data['code']}: {data['message']}")
    elif not line:
        event = None  # an empty line ends an event; ": still working" is skipped

In a page or an app, show the pieces as they come, then put done.answer in their place. If you close the connection before done, the question shows as stopped in your dashboard and costs nothing.

event: error
data: {"message": "Something went wrong on the lab side. Please try again in a moment.", "code": "lab_error"}

Conversations

The API remembers nothing between requests. For a follow-up, send the earlier turns in history: each turn is the question (q) and the answer the lab gave (a), oldest first. The lab reads the last 3 turns.

// chat.mjs, for Node 18 or newer: a question and a follow-up
const API_URL = 'https://lab-api.kaspa.news/v1/ask';
let history = []; // earlier turns, oldest first

for (const question of ['What is GHOSTDAG?', 'How is DAGKnight different?']) {
  const res = await fetch(API_URL, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.KASPA_LAB_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ question, history }),
  });
  const data = await res.json();
  if (!res.ok) throw new Error(`${data.code}: ${data.error}`);
  console.log(`> ${question}\n${data.answer}\n`);
  history.push({ q: question, a: data.answer });
  history = history.slice(-3); // the lab reads the last 3 turns
}

# chat.py: a question and a follow-up
import os

import requests

URL = 'https://lab-api.kaspa.news/v1/ask'
KEY = os.environ['KASPA_LAB_KEY']
history = []  # earlier turns, oldest first

for question in ['What is GHOSTDAG?', 'How is DAGKnight different?']:
    res = requests.post(URL, headers={'Authorization': f'Bearer {KEY}'},
                        json={'question': question, 'history': history},
                        timeout=180)
    res.raise_for_status()
    answer = res.json()['answer']
    print(f'> {question}\n{answer}\n')
    history.append({'q': question, 'a': answer})
    history = history[-3:]  # the lab reads the last 3 turns

• A follow-up answer gives only the new part; it does not repeat what the earlier answers said.
• Send each answer back exactly as you received it.
• Every question is billed on its own. A longer history gives the lab more to read, so a follow-up can cost a little more.

Errors

Every error is JSON with error, a sentence for people, and code, a short word for your program. Check code, not the sentence: sentences can change.

{
  "error": "Too many requests: this account allows 30 per minute. Try again in 12 seconds.",
  "code": "rate_limited",
  "retry_after": 12
}

When to try again

• 429: wait retry_after seconds (the Retry-After header says the same), then send the request again.
• 500, or any other status from 500 up: try again after a short wait, for example 2 and then 4 seconds, a few times at most.
• 400, 401, 402, 403: trying again does not help until something changes: the request, the key, your balance, a limit or the account.

The client code below does exactly this. Refused requests are not saved and do not show in your Questions list; failed and stopped questions do, at no charge.

Limits and quotas

Limits belong to your account: all its keys and its chat box share them. The lab owner sets them, and your dashboard shows them with what is left, on Overview and in Help.

• Monthly limits start again on the 1st of every month at 00:00 UTC.
• Limits are checked when a question arrives. So the question that crosses a limit, or takes the last of a balance, is still answered and billed, and the next one is refused. A balance can go a little below $0 this way; the next top-up covers that first.
• The per-minute count includes every request that gets past these checks, bad requests (400) too.
• Each request: a question of up to 12,000 characters, the last 3 turns of history, a body of up to 128,000 bytes.
• Up to 10 active keys per account.

To ask for other limits, write to [email protected].

Pricing and billing

The API is paid per answered question. Each answer's price is exactly what it used, worked out to 7 decimal places in US dollars. It comes back in price_usd, and your dashboard lists it with every question.

There is no fixed price list: a long, detailed answer costs more than a short one. Your dashboard shows this month's average price per question, and about how many questions your balance buys at that price.

What costs nothing

• Questions that fail, and questions you stop by closing the connection.
• Fixed lines: questions that are not about Kaspa, and links to X posts the lab does not have.
• Short questions about one live network number.
• Refused requests: 400, 401, 402, 403 and 429.

Prepaid or free

An account is either prepaid or free. Billing says which.

• Prepaid: you top up a balance, and each answered question takes its exact price from it. At $0 new questions stop with 402 balance_empty and your chat box rests; a top-up starts them again at once. Money you do not use stays on the balance, and the dashboard tells you when the balance runs low.
• Free: the lab pays for your questions. Your account's limits still apply.

The lab can also add credit to a prepaid balance, for example as a gift or a correction. It shows in your payments as "From the lab".

Top up with KAS

1. In Billing, pick an amount in dollars (a button, or another amount between the smallest and largest top-up shown there) and press Pay with KAS.
2. Billing shows the exact KAS amount and the address, each with a copy button. Send exactly that amount in one payment: the exact amount tells the lab the payment is yours.
3. The page looks for your payment every 15 seconds (or press I have paid: check now), and the lab also checks on its own. The money is on your balance as soon as the payment is seen.

An amount is offered for 6 hours. A payment that arrives later still counts for 30 days, at the lower of the dollars you picked and what the KAS sent is worth when it arrives. Up to 3 amounts can wait at once, and up to 10 can be made in a day. Not now puts an amount aside; it still counts if you pay it later. The receipt is the transaction on kaspa.stream.

The chat box without the kaspa.news mark

Your chat box shows a small kaspa.news mark. The plan without it is in Billing, with its price. With KAS, one payment buys a number of days, shown there, and new days are added after the ones already paid. Paying monthly by card comes with card payments.

Bills and statements

• Overview shows what you spent today, this week (from Monday), this month and in all, and spending per day for 30 days. Days and months follow UTC.
• Questions lists every question, from the API and from your chat box, with its answer, time, status (answered, failed or stopped), price and request id.
• Billing lists your payments with their receipts, and a statement for each month as a CSV file:

time (UTC),request id,channel,question,status,price (USD)
2026-10-16T09:12:40+00:00,req_9f2c4e1a7b3d5c60,api,What is GHOSTDAG?,answered,0.0251000
2026-10-16T09:20:03+00:00,req_3b7d0c5e2a9f4410,embed,How do I run a Kaspa node?,answered,0.0313000
2026-10-16T09:31:55+00:00,req_77a1e0c9d4b2f356,api,What is DAGKnight?,failed,0.0000000
,,,Total for 2026-10,3 requests,0.0564000

The website chat box

The chat box puts the lab's own chat on your website: answers with talks that play inside them, sources with their icons, the question cards (you can hide them) and ELI5. It needs no key and no code on your server. Its answers go on your account's bill and show in your Questions list as "Chat box".

Add it to your site

1. In your dashboard, open Chat box, switch it on and list your websites.
2. Pick a design, then copy your code: a round button in the corner, or a box inside a page.
3. Paste it into your site.

A round button in the corner. Put this line before </body>. It adds one button in the corner (round, or with your words next to its icon) that opens the chat. The chat loads on the first tap, opens full screen on screens under 520 pixels wide, and nothing else on your page is touched.

<script src="https://lab.kaspa.news/embed.js" data-lab="emb_0123456789abcdef" defer></script>

A box inside a page. Put this where the chat should be. Keep referrerpolicy="strict-origin": from it the lab knows which website the box is on.

<iframe src="https://lab.kaspa.news/embed/emb_0123456789abcdef" title="Ask about Kaspa" referrerpolicy="strict-origin"
  style="width:100%;height:640px;border:0;border-radius:16px" loading="lazy" allow="clipboard-write"></iframe>

Copy the code from your dashboard: it has your own chat box id in place of emb_0123456789abcdef. The id is not a secret; it works only on your websites.

If your site sets a Content-Security-Policy, allow the lab in it. The round button needs these three:

script-src https://lab.kaspa.news; frame-src https://lab.kaspa.news; connect-src https://lab.kaspa.news

If your policy also limits styles (a style-src, or a default-src without one), the round button needs 'unsafe-inline' in style-src as well, because its look is a small style the script adds. The box inside a page needs only frame-src https://lab.kaspa.news; under such a policy the browser ignores its style attribute, so give the frame its size in your own stylesheet.

Your websites

• List up to 20, one per line, as plain names: example.com, shop.example.com, or *.example.org for every name under it (not example.org itself).
• A two-part name such as example.com also covers www.example.com.
• The box works only on https pages of these websites. A browser will not show it on any other website, and opened on its own it says it works inside a website.
• Change the list at any time; your code stays the same.

Design

Set the look in Chat box, with a live preview. Your code reads the design from the lab each time, so a new design needs no new code. Every style keeps the lab's own chat, with its talks and sources with their icons, and the kaspa.news mark.

The kaspa.news mark

The box shows a small "Answers by kaspa.news" mark at the bottom, in every style. The lab draws it inside its own frame, so your site cannot remove or restyle it, and your logo and design never hide it. In browsers that can tell (Chrome, Edge and other Chromium browsers), a mark that your page covers pauses questions until it shows again. The plan without the mark is in Billing: see Pricing and billing.

What your visitors get

• The same answers and protections as on lab.kaspa.news: a quick check that they are a person, and at most 30 questions in 10 minutes and 300 a day each, two at a time. Past that they see a calm note with a countdown, never an error.
• When your account cannot answer (paused, a monthly limit reached, a prepaid balance at $0), the box says it is resting for now. Too many questions in a minute for your account shows the same calm countdown.
• No Google Analytics, no Share button and no screenshot reading inside the box. A line under the question box tells visitors that questions are saved.

Client code

There is no package to install yet. These small clients, one file each, do what most apps need: ask, stream, follow-ups, and waiting and trying again when the lab says so (429, and 500 or above). Copy one into your project.

// kaspa-lab.mjs: a small client for the Kaspa News Knowledge Lab API
// (Node 18 or newer, no packages)
const API_URL = 'https://lab-api.kaspa.news/v1/ask';

export class LabError extends Error {
  constructor(status, code, message, retryAfter) {
    super(`${status} ${code}: ${message}`);
    Object.assign(this, { status, code, retryAfter });
  }
}

// waits and tries again when told to slow down (429), or when the lab had a
// problem (500 and up)
async function post(body, { key = process.env.KASPA_LAB_KEY, tries = 3 } = {}) {
  for (let attempt = 1; ; attempt++) {
    const res = await fetch(API_URL, {
      method: 'POST',
      headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json' },
      body: JSON.stringify(body),
    });
    if (res.ok) return res;
    const data = await res.json().catch(() => ({}));
    const error = new LabError(res.status, data.code || 'http_error',
      data.error || res.statusText, data.retry_after);
    const retry = res.status === 429 || res.status >= 500;
    if (attempt >= tries || !retry) throw error;
    const seconds = data.retry_after || 2 ** attempt;
    await new Promise(done => setTimeout(done, seconds * 1000));
  }
}

// the answer: { id, answer, price_usd }
export async function ask(question, options = {}) {
  const { history = [], simple = false, ...rest } = options;
  return (await post({ question, history, simple }, rest)).json();
}

// yields { event: 'token', data: text } while the answer is written,
// then { event: 'done', data: the answer }
export async function* stream(question, options = {}) {
  const { history = [], simple = false, ...rest } = options;
  const res = await post({ question, history, simple, stream: true }, rest);
  const decoder = new TextDecoder();
  let buffer = '';
  for await (const chunk of res.body) {
    buffer += decoder.decode(chunk, { stream: true });
    let end;
    while ((end = buffer.indexOf('\n\n')) >= 0) {
      const block = buffer.slice(0, end);
      buffer = buffer.slice(end + 2);
      const event = block.match(/^event: (.*)$/m)?.[1];
      const data = block.match(/^data: (.*)$/m)?.[1];
      if (!event || data === undefined) continue;
      const value = JSON.parse(data);
      if (event === 'error') throw new LabError(200, value.code, value.message);
      if (event === 'token' || event === 'done') yield { event, data: value };
    }
  }
}

# kaspa_lab.py: a small client for the Kaspa News Knowledge Lab API
# (pip install requests)
import json
import os
import time

import requests

API_URL = 'https://lab-api.kaspa.news/v1/ask'


class LabError(Exception):
    """A refusal or a failure, with the lab's code (balance_empty, ...)."""

    def __init__(self, status, code, message, retry_after=None):
        super().__init__(f'{status} {code}: {message}')
        self.status, self.code, self.retry_after = status, code, retry_after


class KaspaLab:
    def __init__(self, key=None, url=API_URL, timeout=180, tries=3):
        self.key = key or os.environ['KASPA_LAB_KEY']
        self.url, self.timeout, self.tries = url, timeout, tries

    def ask(self, question, history=None, simple=False):
        """The answer as a dict: id, answer and price_usd."""
        body = {'question': question, 'history': history or [], 'simple': simple}
        return self._post(body).json()

    def stream(self, question, history=None, simple=False):
        """Yields ('token', text) while the answer is written, then
        ('done', the answer as a dict)."""
        body = {'question': question, 'history': history or [], 'simple': simple,
                'stream': True}
        event = None
        for line in self._post(body, stream=True).iter_lines(decode_unicode=True):
            if line.startswith('event: '):
                event = line[len('event: '):]
            elif line.startswith('data: ') and event:
                data = json.loads(line[len('data: '):])
                if event == 'error':
                    raise LabError(200, data['code'], data['message'])
                if event in ('token', 'done'):
                    yield event, data
            elif not line:
                event = None

    def _post(self, body, stream=False):
        # waits and tries again when told to slow down (429), or when the lab
        # had a problem (500 and up)
        for attempt in range(1, self.tries + 1):
            res = requests.post(self.url, json=body, stream=stream,
                                timeout=self.timeout,
                                headers={'Authorization': f'Bearer {self.key}'})
            if res.ok:
                return res
            try:
                data = res.json()
            except ValueError:
                data = {}
            error = LabError(res.status_code, data.get('code', 'http_error'),
                             data.get('error', res.reason), data.get('retry_after'))
            retry = res.status_code == 429 or res.status_code >= 500
            if attempt == self.tries or not retry:
                raise error
            time.sleep(error.retry_after or 2 ** attempt)

Use it like this:

// app.mjs, next to kaspa-lab.mjs: node app.mjs
import { ask, stream, LabError } from './kaspa-lab.mjs';

try {
  const first = await ask('What is GHOSTDAG?');
  console.log(first.answer, `\n($${first.price_usd}, ${first.id})\n`);

  const history = [{ q: 'What is GHOSTDAG?', a: first.answer }];
  let shown = '';
  const next = stream('How is DAGKnight different?', { history });
  for await (const { event, data } of next) {
    if (event === 'token') {
      shown += data;
      process.stdout.write(data);
    } else {
      // done: the complete, checked answer
      const same = data.answer.startsWith(shown);
      console.log(same ? data.answer.slice(shown.length) : `\n\n${data.answer}`);
      console.log(`($${data.price_usd}, ${data.id})`);
    }
  }
} catch (error) {
  if (error instanceof LabError && error.code === 'balance_empty') {
    console.log('Top up in the dashboard, then ask again.');
  }
  throw error;
}

# app.py, next to kaspa_lab.py: python app.py
from kaspa_lab import KaspaLab, LabError

lab = KaspaLab()  # reads KASPA_LAB_KEY
try:
    first = lab.ask('What is GHOSTDAG?')
    print(first['answer'], f"\n(${first['price_usd']}, {first['id']})\n")

    history = [{'q': 'What is GHOSTDAG?', 'a': first['answer']}]
    shown = ''
    for kind, data in lab.stream('How is DAGKnight different?', history=history):
        if kind == 'token':
            shown += data
            print(data, end='', flush=True)
        else:  # done: the complete, checked answer
            answer = data['answer']
            same = answer.startswith(shown)
            print(answer[len(shown):] if same else '\n\n' + answer)
            print(f"(${data['price_usd']}, {data['id']})")
except LabError as error:
    if error.code == 'balance_empty':
        print('Top up in the dashboard, then ask again.')
    raise

API spec file

The API is described in a standard OpenAPI 3.1 file: lab.kaspa.news/docs/openapi.json. Import it into Postman or Insomnia, or make a client in your programming language with an OpenAPI generator. It has every field, response and error code on this page.

Help and support

• Report a problem in your dashboard, under Help: say what it is about, add the request id if it is about one question, and tell us what happened. Or open the question in your Questions list and press "Report a problem with this answer", which fills in its id. Reports go to [email protected], and the answer comes by email to the address you sign in with. You can send up to 5 an hour.
• Or write to [email protected].

Changelog

Terms of use

In plain words: how the lab works today.

• Kaspa only. The lab answers questions about Kaspa, including everything built on it. Other questions get one fixed line.
• No financial advice. Answers never predict prices or give trading or investment advice.
• Check before you rely on it. Answers come from real sources and code is checked, but an answer can still be wrong or out of date. Test code yourself, and never treat a contract as safe because it compiles.
• Your keys, your bill. Every question asked with your keys or in your chat box goes on your account's bill. Keep keys secret, and revoke a key that leaks.
• Limits. Your account's limits apply. The lab owner can change them, or pause an account; a paused account's keys and chat box do not answer.
• The mark stays. The chat box shows the kaspa.news mark unless your account has the plan without it. Do not cover or hide it.

Questions about these terms: [email protected].

Privacy

• Questions and answers are saved. Every question asked through the API, your chat box or lab.kaspa.news is kept with its answer, to improve the lab. This cannot be turned off, so keep secrets and personal details out of questions.
• Who sees them. You see your own account's questions and answers, from your keys and from your chat box. A visitor of your chat box sees only their own chat. The lab owner sees all of them. They are not published: a page with an answer exists only when someone on lab.kaspa.news presses Share, which the API and the chat box do not have.
• What is kept with them. For an API question: the time, the key, the status and the price, and technical details of how it was answered that only the lab owner sees. For the chat box and lab.kaspa.news, also a visitor code that changes every day, the country and whether it came from a phone, tablet or computer, for the lab's own statistics. IP addresses are never stored.
• Keys. The lab keeps only a fingerprint of each key, never the key itself.
• Analytics. The API, the chat box on your website and these docs send nothing to Google. The chat at lab.kaspa.news uses Google Analytics as kaspa.news does: page views, and the first 100 characters of each question with emails, Kaspa addresses, keys and long numbers taken out.
• Your account. The lab keeps your name, the email you sign in with, your payments and your problem reports. Reports are emailed to [email protected] so we can answer you. A KAS payment is a public transaction on the Kaspa network, like any other.

Questions about your data: [email protected].