Machine-to-Machine SDK

npm install @nodatachat/sdk

import { NoData } from '@nodatachat/sdk';

const nd = new NoData({ apiKey: 'sk_live_...' });

// THE primitive — give AI access without giving it the data.
const { decision, answer, proof } = await nd.compute({
  question: 'What is the claim status?',
  clearance: 'internal',
  sections: [
    { title: 'Status', text: 'Approved on 2026-07-14' },
    { title: 'SSN',    text: '123-45-6789' },   // out of clearance → never sent
  ],
});
// decision: 'allow' · answer over the permitted sections only.

// The Prove verb — confirm the proof, without decrypting anything.
const v = await nd.verify(proof.id);   // { authentic, unaltered, signer }

const result = await nd.batchNative([
  { op: 'encrypt', field: 'phone',  value: '0501234567' },
  { op: 'encrypt', field: 'email',  value: 'david@company.com' },
  { op: 'encrypt', field: 'id',     value: '123456789' },
  { op: 'decrypt', field: 'ssn',    ciphertext: 'aes256gcm:v1:...' },
]);
// result.ok === 4, result.failed === 0

const encrypted = await nd.encryptObject(
  { name: 'David', phone: '050...', email: 'd@x.com', age: 30 },
  ['phone', 'email']
);
// { name: 'David', phone: 'aes256gcm:v1:...', email: 'aes256gcm:v1:...', age: 30 }

THE primitive. Decide what a subject may see, answer over the authorized slice, and prove it — the billed unit.

Field-level encrypt/decrypt (nd.engines.blindRelay). Server relays ciphertext; content never stored.

Secure tunnels between systems. E2E encrypted. Verification codes. Burn-after-read.

Receive webhooks encrypted at rest. PBKDF2 + AES-256-GCM. You hold the key.

Burn-after-read delivery. One link. One view. Gone.

SOC-ready audit trail. Metadata only — never content. Proof certificates.

Zero-knowledge storage. You encrypt client-side. Server stores blindly.

// System A — creates a channel
const ch = await nd.channel.create({
  ttl: '1h',
  requireVerification: true,
});

// System B — sends credit card data
await nd.channel.send({
  token: ch.channel_token,
  data: { card: '4111111111111111', cvv: '123', exp: '12/28' },
  burnAfterRead: true,
});

// System A — receives
const result = await nd.channel.receive({
  token: ch.channel_token,
  verificationCode: '482901',
});
const card = JSON.parse(result.data);

import express from 'express';
import { nodataExpress } from '@nodatachat/sdk/express';

const app = express();

app.use('/api/customers', nodataExpress({
  apiKey: 'sk_live_...',
  encryptFields: ['phone', 'email', 'id_number'],
}));

// Every response with phone/email/id_number → auto-encrypted
// No code changes in your routes

import Fastify from 'fastify';
import { nodataFastify } from '@nodatachat/sdk/fastify';

const app = Fastify();

app.register(nodataFastify, {
  apiKey: 'sk_live_...',
  encryptFields: ['phone', 'email', 'id_number'],
});

// Master key creates a scoped service account
const res = await fetch('/api/v1/service-account', {
  method: 'POST',
  headers: { Authorization: 'Bearer sk_live_MASTER_KEY' },
  body: JSON.stringify({
    name: 'payment-service',
    scopes: ['encrypt', 'decrypt'],
    rate_limit_per_minute: 500,
    daily_quota: 100000,
    expires_in_days: 90,
    allowed_ips: ['10.0.0.0/8'],
  }),
});
// → { key: "svc_live_abc123..." } — shown ONCE

import { NoData } from '@nodatachat/sdk';

const nd = new NoData({ apiKey: process.env.NODATA_API_KEY! });

// Decide + answer over only the authorized sections, with a proof.
const { decision, answer, proof } = await nd.compute({
  question: 'Is this customer past due?',
  clearance: 'internal',
  sections: [
    { title: 'Balance', text: customer.balance },
    { title: 'SSN',     text: customer.ssn },   // out of clearance → never sent
  ],
});
// The model only ever saw the sections it was cleared for.