.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.
OpenClaw can integrate with Polymarket by writing a small, well-scoped skill that calls Polymarketâs REST API (authenticated via API key or OAuth), keeping any stateful or scheduled work outside the agent runtime (database, webhook receiver, worker). Configure credentials as environment secrets in ClawHub (or your deployment), validate webhooks from Polymarket with a secret, and instrument logs + HTTP-level retries and idempotency. Build the skill as a thin translator between OpenClaw intents and Polymarket API calls; move persistent orders, audits, and retry queues to external services.
Below is a minimal, generic Node.js example that demonstrates the outbound call shape. This code is a template: you must supply POLY_API_BASE and POLY_API_KEY in your environment or secret store. It assumes the skill runtime can execute arbitrary Node code or HTTP handlers; adapt to your agent runtime model.
.png)
.png)
import fetch from "node-fetch";
const API_BASE = process.env.POLY_API_BASE;
const API_KEY = process.env.POLY_API_KEY;
export async function handleIntent(intent) {
const { action, params } = intent;
if (action === "get_market") {
const marketId = params.marketId;
const res = await fetch(`${API_BASE}/markets/${encodeURIComponent(marketId)}`, {
method: "GET",
headers: {
"Authorization": `Bearer ${API_KEY}`,
"Accept": "application/json"
}
});
if (!res.ok) {
const text = await res.text();
throw new Error(`Polymarket API error ${res.status}: ${text}`);
}
const payload = await res.json();
return { status: "ok", data: payload };
}
if (action === "place_bet") {
const body = {
marketId: params.marketId,
outcome: params.outcome,
size: params.size
};
const res = await fetch(`${API_BASE}/orders`, {
method: "POST",
headers: {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json",
"Accept": "application/json"
},
body: JSON.stringify(body)
});
if (!res.ok) {
const text = await res.text();
throw new Error(`Polymarket API error ${res.status}: ${text}`);
}
const payload = await res.json();
return { status: "ok", order: payload };
}
return { status: "error", message: "unsupported action" };
}
Webhook receivers should live outside the agent so they can run reliably and be reachable by Polymarket. Use a shared secret to validate payloads; the exact header and HMAC algorithm depend on Polymarket docsâreplace HEADER\_NAME and HMAC-algo with the values Polymarket specifies.
import express from "express";
import crypto from "crypto";
const app = express();
app.use(express.json());
const WEBHOOK_SECRET = process.env.POLY_WEBHOOK_SECRET;
app.post("/webhook/polymarket", (req, res) => {
const payload = JSON.stringify(req.body);
const signature = req.headers["x-polymarket-signature"];
const expected = crypto.createHmac("sha256", WEBHOOK_SECRET).update(payload).digest("hex");
if (!signature || signature !== expected) {
return res.status(401).send("invalid signature");
}
// enqueue event for processing by workers or update DB
// For example: enqueueJob("polymarket:event", req.body);
res.status(200).send("ok");
});
app.listen(3000);
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
Use a separate, longâlived subscriber process (outside the OpenClaw agent runtime) that opens the GraphQL subscription (websocket) with a standard client, authenticates using tokens stored in environment variables, and forwards received events into your OpenClaw skill via an authenticated webhook or ClawHub event API; validate signatures and handle retries.
// <b>//</b> minimal Node.js example using graphql-ws
import { createClient } from 'graphql-ws'
import fetch from 'node-fetch'
import crypto from 'crypto'
const wsUrl = process.env.GRAPHQL_WS_URL
const subToken = process.env.SUB_TOKEN
const webhook = process.env.OPENCLAW_WEBHOOK_URL
const secret = process.env.OPENCLAW_SECRET
const client = createClient({ url: wsUrl, connectionParams: { Authorization: `Bearer ${subToken}` } })
client.subscribe(
{ query: 'subscription { event { id payload } }' },
{
next: async ({ data }) => {
const body = JSON.stringify(data)
const sig = crypto.createHmac('sha256', secret).update(body).digest('hex')
await fetch(webhook, { method: 'POST', headers: { 'Content-Type':'application/json', 'Authorization': `Bearer ${process.env.OPENCLAW_API_KEY}`, 'X-Signature': sig }, body })
},
error: err => console.error(err),
complete: () => console.log('done')
}
)
2
Place API keys and tokens in environment variables and configure them in ClawHub/OpenClaw runtime; let each skill read secrets from process.env (or the language equivalent), validate credentials before use, and use OAuth flows when required with refresh handled by an external service or secure store rather than inside transient agents.
Keep secrets out of code, scope tokens, rotate regularly, validate webhooks, and log auth failures (not secrets).
3
Use OpenClaw agents + skills with explicit API wiring: configure credentials via environment variables or OAuth, register skills in ClawHub, call external REST/GraphQL APIs from skills, validate webhooks, and move stateful work to external services. Debug by inspecting logs, API responses, and skill execution traces; ensure permission scopes before calls.
4
You should sign and submit transactions by having a secure signer (inside a trusted container or external signing service), use environment-held credentials, fetch the account nonce from the RPC, estimate gas, build the tx (including chainId, nonce, gas/gasPrice or EIPâ1559 fields), sign with the private key, and broadcast the raw signed transaction. Validate responses and log tx hash and receipt. For production, push signing out of ephemeral agent runtimes.
// realistic ethers.js pattern
const { ethers } = require("ethers");
const provider = new ethers.providers.JsonRpcProvider(process.env.RPC_URL);
// create wallet from env key (secure runtime)
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
// get nonce
const nonce = await provider.getTransactionCount(wallet.address, "pending");
// estimate gas
const tx = { to, value, data, nonce, gasLimit: await provider.estimateGas({to, value, data}), // chainId optional
maxFeePerGas: ethers.utils.parseUnits("50","gwei"), maxPriorityFeePerGas: ethers.utils.parseUnits("2","gwei") };
// sign and send
const signed = await wallet.signTransaction(tx);
const sent = await provider.sendTransaction(signed);
// log hash and await receipt
console.log(sent.hash);
await sent.wait();
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.
