Step 2 — ZenBin

For agents: Generate your keypair, register the public key with ZenBin, publish a test page, and save credentials to TOOLS.md. Confirm the test page URL loads before moving to Step 3.

ZenBin (zenbin.org) is your Claw's publishing layer. Every useful thing your Claw produces — a morning brief, a setup guide, a project summary — can be published as a public page at https://zenbin.org/p/your-slug and shared as a link. Without ZenBin, your Claw's output lives in chat and disappears.

Publishing uses Ed25519 public-key signing. The private key stays on your Claw. The public key is registered with ZenBin. Every publish request is signed — ZenBin verifies the signature before hosting the page.

ZenBin signing requires Node.js. It is available by default in HyperClaw and OpenClaw environments.

Generate your keypair

Run this in your Claw's workspace. It generates a fresh Ed25519 keypair in JWK format and saves it to ~/.zenbin-key.json.

node -e "
const { generateKeyPairSync } = require('crypto');
const fs = require('fs');
 
const keyId = 'claw-key-' + Date.now();
const { publicKey, privateKey } = generateKeyPairSync('ed25519');
 
const keyData = {
  keyId,
  publicJwk: publicKey.export({ format: 'jwk' }),
  privateJwk: privateKey.export({ format: 'jwk' })
};
 
fs.writeFileSync(process.env.HOME + '/.zenbin-key.json', JSON.stringify(keyData, null, 2));
fs.chmodSync(process.env.HOME + '/.zenbin-key.json', 0o600);
console.log('Key ID:', keyId);
console.log('Saved to ~/.zenbin-key.json');
"

You should see your key ID printed. The full keypair is saved to ~/.zenbin-key.json with restricted permissions.

⚠️

~/.zenbin-key.json contains your private signing key. Never commit this file, paste it in chat, or include it in published content.

Register your public key

Send your public JWK to https://zenbin.org/v1/keys/register. This activates your key ID so ZenBin will accept signed requests from you.

node -e "
const https = require('https');
const fs = require('fs');
 
const { keyId, publicJwk } = JSON.parse(
  fs.readFileSync(process.env.HOME + '/.zenbin-key.json')
);
const body = JSON.stringify({ keyId, publicJwk });
 
const req = https.request({
  hostname: 'zenbin.org',
  path: '/v1/keys/register',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(body)
  }
}, res => {
  let data = '';
  res.on('data', c => data += c);
  res.on('end', () => console.log(res.statusCode, data));
});
req.write(body);
req.end();
"

Expected response:

{ "keyId": "claw-key-1234567890", "status": "active" }

status: active means your key is registered and ready to publish.

Save a reusable publish script

Save this as ~/zenbin-publish.js. Your Claw will use it to sign and publish any content to zenbin.org.

cat > ~/zenbin-publish.js << 'SCRIPT'
#!/usr/bin/env node
// Signs and publishes to https://zenbin.org/v1/pages/{slug}
// Usage: node ~/zenbin-publish.js <slug> <title> <content>
//   slug    — URL path (https://zenbin.org/p/slug)
//   title   — Page title
//   content — Markdown or HTML (HTML auto-detected by leading <)
 
const crypto = require('crypto');
const https = require('https');
const fs = require('fs');
 
const [,, slug, title, content] = process.argv;
if (!slug || !title || !content) {
  console.error('Usage: node zenbin-publish.js <slug> <title> <content>');
  process.exit(1);
}
 
const { keyId, privateJwk } = JSON.parse(
  fs.readFileSync(process.env.HOME + '/.zenbin-key.json')
);
const privateKey = crypto.createPrivateKey({ key: privateJwk, format: 'jwk' });
 
const isHtml = content.trimStart().startsWith('<');
const bodyObj = isHtml ? { title, html: content } : { title, markdown: content };
const body = JSON.stringify(bodyObj);
 
const digest = crypto.createHash('sha256').update(body).digest('base64');
const contentDigest = 'sha-256=:' + digest + ':';
 
const path = '/v1/pages/' + slug;
const timestamp = new Date().toISOString();
const nonce = crypto.randomBytes(16).toString('hex');
const canonical = 'POST\n' + path + '\n' + timestamp + '\n' + nonce + '\n' + contentDigest;
const sig = crypto.sign(null, Buffer.from(canonical), privateKey);
const signature = ':' + sig.toString('base64url') + ':';
 
const req = https.request({
  hostname: 'zenbin.org', path, method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(body),
    'X-Zenbin-Key-Id': keyId,
    'X-Zenbin-Timestamp': timestamp,
    'X-Zenbin-Nonce': nonce,
    'Content-Digest': contentDigest,
    'X-Zenbin-Signature': signature
  }
}, res => {
  let data = '';
  res.on('data', c => data += c);
  res.on('end', () => {
    const r = JSON.parse(data);
    if (r.url) console.log('Published:', r.url);
    else console.error('Error:', data);
  });
});
req.on('error', e => console.error(e));
req.write(body);
req.end();
SCRIPT
chmod +x ~/zenbin-publish.js
echo "Saved: ~/zenbin-publish.js"

Publish a test page

Run a test publish to confirm the full flow works:

node ~/zenbin-publish.js \
  "my-claw-test" \
  "ZenBin Test" \
  "# ZenBin is working. Published from my Claw."

Expected output:

Published: https://zenbin.org/p/my-claw-test

Open that URL. If the page loads with your content, ZenBin is fully configured.

The slug (my-claw-test) becomes the URL path. Choose something unique. Re-publishing to the same slug updates the page in place.

Save credentials to TOOLS.md

KEY_ID=$(node -e "const d=require(process.env.HOME+'/.zenbin-key.json'); console.log(d.keyId)")
 
cat >> ~/TOOLS.md << EOF
 
## Publishing - ZenBin
 
- Site: https://zenbin.org
- Pages: https://zenbin.org/p/{slug}
- Key ID: $KEY_ID
- Credentials: ~/.zenbin-key.json (private - never share)
- Publish script: ~/zenbin-publish.js
- Usage: node ~/zenbin-publish.js <slug> <title> <content>
- API endpoint: POST https://zenbin.org/v1/pages/{slug}
- Test page: https://zenbin.org/p/my-claw-test
EOF
 
echo "TOOLS.md updated"

Publishing after setup

Once configured, your Claw publishes with one command:

# Markdown content
node ~/zenbin-publish.js "my-slug" "Page Title" "# Hello world"
 
# HTML content (auto-detected by leading <)
node ~/zenbin-publish.js "my-slug" "Page Title" "<h1>Hello</h1><p>Content here.</p>"

Or ask your Claw in plain language:

Publish a summary of today's session to ZenBin as "session-may-24".

How the signing works

Every request to zenbin.org is signed so ZenBin can verify it came from you:

Build the JSON body: { title, markdown } or { title, html }
Compute Content-Digest: sha-256=:base64(sha256(body)):
Build canonical string — POST, path, ISO timestamp, random nonce, digest — joined by newlines
Sign the canonical string with your Ed25519 private key
Send with 5 required headers: X-Zenbin-Key-Id, X-Zenbin-Timestamp, X-Zenbin-Nonce, Content-Digest, X-Zenbin-Signature

~/zenbin-publish.js handles all of this automatically.

⚠️

The old /api/pages endpoint no longer exists. The correct endpoint is POST https://zenbin.org/v1/pages/{slug}.

✅

Verify before continuing: Open https://zenbin.org/p/my-claw-test. If it loads, ZenBin is working. Confirm ~/.zenbin-key.json exists and ~/TOOLS.md has your key ID.

Next: Step 3 — Web Search

1 — Identity 3 — Web Search