SDK reference

Getter: "test", "live", or "unknown", derived from the key prefix without a network call.

→ KeyMode | "unknown"

Getter: the public prefix plus dots. Safe to log.

→ string

Getter: the API root this client is pointed at.

→ string

One round trip that confirms the key works and reports the account slug and scopes. Never throws — failures come back as { ok: false, error }.

→ Promise<{ ok, latencyMs, account?, scopes?, error? }>

const health = await nd.ping();
if (!health.ok) process.exit(1);

Escape hatch for endpoints the SDK doesn't model yet. Same auth, retries, and error mapping as the typed methods.

→ Promise<T>

const data = await nd.request<{ items: unknown[] }>(
  "GET",
  "/some/new/endpoint",
  { query: { limit: 10 } },
);

A page of published listings. Filter with q, type, category; paginate with limit and cursor. The returned Page is async-iterable over every subsequent page.

→ Promise<Page<Asset>>

const page = await nd.models.list({ q: "grasping", limit: 50 });
for await (const asset of page) console.log(asset.slug);

The same walk as an async generator, when you'd rather not hold the first Page.

→ AsyncGenerator<Asset>

One published listing by id or URL slug. Unpublished listings are not addressable.

→ Promise<Asset>

Publishes a listing. price_cents is integer cents — 0 for free, ≥100 for paid. Attach a file by uploading out of band first and passing storage_path.

→ Promise<Asset>

const asset = await nd.models.create({
  title: "Bin-Picking Policy v2",
  description: "Diffusion policy trained on 40k grasps.",
  type: "policy",
  price_cents: 4900,
});

Edits metadata, price, or publish state on a listing you own. Another account's listing reads as 404, not 403.

→ Promise<Asset>

Unpublishes a listing. Purchase history and buyer download rights are preserved.

→ Promise<{ id, deleted }>

Published datasets, cursor-paginated.

→ Promise<Page<Asset>>

One dataset by id or slug.

→ Promise<Asset>

Publishes a dataset — `type` is set for you.

→ Promise<Asset>

The authenticated account plus the key's mode and scopes. An empty scopes array means unrestricted.

→ Promise<Account>

Metered inference spend over a window (1–365 days, default 30), rolled up and per model. Costs come back in USD micros and dollars.

→ Promise<Usage>

const usage = await nd.account.usage({ days: 7 });
console.log(usage.summary.cost_usd);

Sales plus an all-time summary. payouts_paused distinguishes 'nothing owed' from 'owed but not moving' — balances keep accruing while it's true.

→ Promise<Payouts>

const payouts = await nd.payouts.retrieve({ limit: 100 });
console.log(payouts.summary.net_cents / 100, "USD");

All endpoints on the account. Never includes secrets.

→ Promise<WebhookEndpoint[]>

Registers an endpoint and returns its signing secret exactly once. Unknown event types are silently dropped, so read it back to confirm.

→ Promise<WebhookEndpoint>

const endpoint = await nd.webhookEndpoints.create({
  url: "https://example.com/hooks",
  events: ["listing.purchased"],
});
await store.set("secret", endpoint.secret!); // shown once

One endpoint's current configuration.

→ Promise<WebhookEndpoint>

Change the URL, replace the subscription list, or set enabled: false to pause without losing history.

→ Promise<WebhookEndpoint>

Permanently removes the endpoint and stops all deliveries.

→ Promise<{ id, deleted }>

Recent delivery attempts with response status and attempt count. First place to look when a handler goes quiet.

→ Promise<WebhookDelivery[]>

The Node model catalog with context windows and live per-token pricing. Fetch this rather than hardcoding prices.

→ Promise<InferenceModel[]>

One buffered completion. Always set max_tokens — it's the only hard ceiling on a runaway generation.

→ Promise<ChatCompletion>

Streams parsed SSE chunks. Never retried mid-flight, and given a long default timeout.

→ AsyncGenerator<ChatCompletionChunk>

for await (const chunk of nd.inference.stream({ model, messages })) {
  process.stdout.write(chunk.choices[0]?.delta.content ?? "");
}

Collects a stream into the full assistant message while optionally handing you each token as it arrives.

→ Promise<string>

Verifies a standard Request and returns the parsed event. Reads the raw body itself, so you can't accidentally verify re-serialized JSON.

→ Promise<WebhookEvent<T>>

import { verifyRequest } from "@node-data/sdk";
 
export async function POST(req: Request) {
  const event = await verifyRequest(req, process.env.ND_WEBHOOK_SECRET!);
  return new Response(null, { status: 204 });
}

The lower-level form, for frameworks that hand you the body and headers separately. Default tolerance is 300 seconds.

→ Promise<WebhookEvent<T>>

Produces an nd-signature header value. Useful for testing your own handler without waiting on a real delivery.

→ Promise<string>

The header name constant: "nd-signature".

→ string