.gif)
We build custom applications 5x faster and cheaper 🚀
Book a Free Consultation
Stuck on an error? Book a 30-minute call with an engineer and get a direct fix + next steps. No pressure, no commitment.
This integration is implemented by making OpenClaw invoke a small, secure external service that holds your Fathom credentials and calls Fathom’s API — not by embedding long‑lived API keys or persistent state inside the agent runtime. Configure the OpenClaw skill in ClawHub to call your service (HTTP webhook or serverless function), store Fathom credentials as environment secrets, and design the skill to send only the event/context needed. Authenticate to Fathom from the external service (API key or OAuth as Fathom requires), validate incoming requests from OpenClaw, handle retries/batching/idempotency there, and monitor logs and HTTP responses to debug issues. Below are concrete, practical steps, security notes, and real REST examples you can use as a template; replace the example endpoint and header names with the exact values from Fathom’s docs and with your ClawHub configuration values.
Replace the placeholder URL and header names with the values from Fathom’s API docs and use your own secret names.
.png)
.png)
const express = require('express');
const fetch = require('node-fetch');
const app = express();
app.use(express.json());
const FAITHOM_API_KEY = process.env.FATHOM_API_KEY; <b>//</b> set this in your secrets store
const INCOMING_SECRET = process.env.INCOMING_SECRET; <b>//</b> shared secret between ClawHub skill and this endpoint
app.post('/track', async (req, res) => {
const incomingSignature = req.get('x-incoming-secret');
if (!incomingSignature || incomingSignature !== INCOMING_SECRET) {
return res.status(401).json({ error: 'unauthorized' });
}
const { eventName, properties, userId, eventId, timestamp } = req.body;
// Map to the Fathom API payload format (consult Fathom docs)
const fathomBody = {
<b>//</b> adapt to the exact Fathom API fields
name: eventName,
properties,
user_id: userId,
id: eventId,
timestamp,
};
try {
const resp = await fetch('https://api.example-fathom.com/v1/events', { <b>//</b> replace with real endpoint
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${FAITHOM_API_KEY}`,
},
body: JSON.stringify(fathomBody),
});
const text = await resp.text();
if (!resp.ok) {
console.error('Fathom API error', resp.status, text);
<b>//</b> Optionally enqueue for retry here
return res.status(502).json({ error: 'failed_to_forward', details: text });
}
return res.status(200).json({ success: true });
} catch (err) {
console.error('Network or code error', err);
<b>//</b> Optionally enqueue for retry here
return res.status(500).json({ error: 'internal_error' });
}
});
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`listening ${PORT}`));
This is the minimal JSON the skill can POST to your /track endpoint. Configure the skill to call via HTTPS and include the incoming-secret header.
curl -X POST "https://your-endpoint.example/track" \
-H "Content-Type: application/json" \
-H "x-incoming-secret: ${INCOMING_SECRET}" \
-d '{
"eventName": "signup_complete",
"properties": {"plan":"pro"},
"userId": "anon-1234",
"eventId": "evt-20260304-0001",
"timestamp": "2026-03-04T12:00:00Z"
}'
Speak one‑on‑one with a senior engineer about your no‑code app, migration goals, and budget. In just half an hour you’ll leave with clear, actionable next steps—no strings attached.
1
Using a Fathom OAuth token will return 401 if OpenClaw does not accept that token's audience, issuer, scopes, or format — common causes are wrong token audience (token issued for Fathom, not OpenClaw), expired/revoked token, missing "Bearer" header, or OpenClaw expecting its own API key or an exchanged token.
curl -H "Authorization: Bearer $TOKEN" https://api.openclaw.example/endpoint
<b>//</b> // decode token to inspect aud/exp/scope
2
Map each Fathom event field to the corresponding ClawEvent protobuf fields, convert types (timestamps to RFC3339 or protobuf Timestamp, IDs to strings/int64 as required), drop unknowns, populate all required fields, and validate/encode the message with a protobuf library before posting to your OpenClaw ingestion endpoint. Schema errors almost always come from missing required fields, wrong types, wrong enum values, or unexpected nested messages.
// Node.js example using protobufjs
const protobuf = require("protobufjs");
const fetch = require("node-fetch");
const root = await protobuf.load("ClawEvent.proto");
// Map Fathom JSON -> ClawEvent payload
const ClawEvent = root.lookupType("claw.ClawEvent");
const payload = {
id: fathom.event_id, // // ensure types match proto
timestamp: new Date(fathom.ts).toISOString(),
// ...map other fields
};
const err = ClawEvent.verify(payload);
if (err) throw Error(err);
const message = ClawEvent.create(payload);
const buffer = ClawEvent.encode(message).finish();
await fetch(process.env.OPENCLAW_INGEST_URL, {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.OPENCLAW_TOKEN}`,
"Content-Type": "application/x-protobuf"
},
body: buffer
});
3
Direct answer: a hanging clawctl apply or a ClawConnector pod in CrashLoopBackOff most often results from missing/invalid credentials or configuration, an operator admission webhook blocking resource creation, RBAC/service‑account permission problems, image/network failures, or the connector crashing while trying to reach Fathom during startup.
Check these in order:
// kubectl describe pod <pod> -n <ns>
kubectl logs <pod> -c claw-connector -n <ns>
kubectl get validatingwebhookconfigurations
4
Use mutual TLS by terminating TLS with a server (OpenClaw runtime or reverse proxy) that requires client certificates, install a CA that issued Fathom’s client certs on the server, give Fathom a client cert+key, and test with an mTLS-capable client. Put certificate paths in environment variables and validate in logs to avoid handshake or verification errors.
curl --cert client.pem --key client.key --cacert ca.pem https://claw-webhook.example/// check OpenClaw and proxy logs for verification errors.
This prompt helps an AI assistant understand your setup and guide you through the fix step by step, without assuming technical knowledge.
From startups to enterprises and everything in between, see for yourself our incredible impact.
They do complex work on extremely fast timelines and effectively manage the testing and pre-launch process to deliver the best possible product. I'm extremely impressed with their execution ability.
