Machine-to-Machine SDK

npm install @nodatachat/sdk

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

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

// Encrypt — server-blind
const { ciphertext } = await nd.encrypt({
  field: 'credit_card',
  value: '4111111111111111',
});
// Store `ciphertext` in YOUR database. NoData stores nothing.

// Decrypt — audited
const { value } = await nd.decrypt({
  field: 'credit_card',
  ciphertext,
  requester: 'billing-service',
});

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 }

Field-level blind relay. Server encrypts, returns 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! });

const { ciphertext } = await nd.encrypt({
  field: 'ssn',
  value: '123-45-6789',
});

// Store in your DB. NoData stores nothing.
await db.query('UPDATE users SET ssn = $1 WHERE id = $2', [ciphertext, userId]);