.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.
Create an OpenClaw skill (registered in ClawHub) that calls Brave Search via its REST API (or the official Brave Search endpoint if you have one) using an API key or OAuth credentials stored as secrets in ClawHub or environment variables. Keep all long-lived state (caches, indexes, rate-limit counters) outside the agent runtime, implement robust request, error, and rate-limit handling in the skill handler, and validate responses before returning structured results to the agent. Test with controlled queries, log requests/responses, and verify credential scopes and network connectivity if anything fails.
Below is a generic Node.js skill handler pattern showing how to call a search API with an API key. Replace BRAVE_API_BASE and header/param names with the real Brave Search API details you get from Brave.
.png)
.png)
<b>//</b> Example: Node.js handler using fetch
<b>//</b> Assumes environment variables: process.env.BRAVE_API_BASE, process.env.BRAVE_API_KEY
const fetch = require('node-fetch');
async function callBraveSearch(query, options = {}) {
const base = process.env.BRAVE_API_BASE; <b>//</b> e.g. "https://api.brave.example" (placeholder)
if (!base) throw new Error('Missing BRAVE_API_BASE env var');
const apiKey = process.env.BRAVE_API_KEY;
if (!apiKey) throw new Error('Missing BRAVE_API_KEY env var');
const params = new URLSearchParams({
q: query,
// <b>//</b> add other API-specific params: page, size, safeSearch, etc.
...options
});
const url = `${base}/search?${params.toString()}`;
const res = await fetch(url, {
method: 'GET',
headers: {
'Accept': 'application/json',
'Authorization': `Bearer ${apiKey}` <b>//</b> or use the correct header required by Brave
},
timeout: 15_000
});
if (!res.ok) {
const text = await res.text().catch(() => '');
throw new Error(`Search API error: ${res.status} ${res.statusText} - ${text}`);
}
const body = await res.json();
return body; <b>//</b> transform as needed
}
// <b>//</b> Example wrapper the OpenClaw skill would call
module.exports.handle = async function handleSkill(inputs) {
const q = inputs.query;
if (!q) return { error: 'Missing query' };
try {
const apiResp = await callBraveSearch(q, { size: 10 });
<b>//</b> Transform apiResp into the skill's structured output
return {
results: apiResp.items || apiResp.results || [],
meta: {
source: 'brave',
raw: apiResp
}
};
} catch (err) {
console.error('Brave search error', err);
return { error: 'Search failed', details: err.message };
}
};
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
Direct answer: A 401 from the OpenClaw Brave Search connector means the request is not being accepted as authenticated — usually because the API key/token is missing, wrong environment variable, sent with the wrong header/format, or required OAuth scopes were not granted to the skill; fix by installing the key/token into ClawHub/runtime secrets, ensuring the skill reads the correct env var, and verifying the header and scopes match Brave’s connector docs.
// Read key from environment and call Brave Search
const key = process.env.BRAVE_SEARCH_KEY; <b>//</b> ensure this env var is set in ClawHub/runtime
fetch('https://api.brave.com/search', {
method: 'GET',
headers: {
'Authorization': `Bearer ${key}` <b>//</b> adjust header if Brave requires a different header
}
});
2
Map each OpenClaw document field to explicit Brave index fields: ensure every doc provides a non-empty title (or a derived fallback), a cleaned body/snippet, a canonical url/id, and typed metadata (date, tags, language, relevance signals). Normalize and index both raw text and a precomputed snippet so Brave can show titles/snippets reliably and relevance signals (freshness, popularity) are numeric fields used by ranking.
// build payload from an OpenClaw document
const payload = {
id: doc.id, // canonical id/url
title: doc.title || extractTitleFromContent(doc.content),
snippet: generateSnippet(doc.content),
content: doc.content,
date: doc.published_at,
tags: doc.tags || [],
clicks: doc.metrics?.clicks || 0
};
// send payload to your search indexing API (placeholder)
await fetch(INDEX_URL, { method: 'POST', body: JSON.stringify(payload) });
3
Handle Brave 429s by reading Retry-After, applying exponential backoff with jitter, capping retries, and reducing concurrent/batch requests. Implement a local token-bucket or queue inside the OpenClaw skill; move that limiter to external infra (Redis/DB) when multiple agents share quota. Tune via env vars and log every 429 for tuning.
// Node.js fetch retry sketch
async function callBrave(url, opts){
const max = Number(process.env.MAX_RETRIES||5);
for(let i=0;i<=max;i++){
const res = await fetch(url,opts);
if(res.status!==429) return res;
const ra = res.headers.get('Retry-After');
const wait = ra? Number(ra)*1000 : Math.min(60000, (2**i)*1000) * Math.random();
await new Promise(r=>setTimeout(r,wait));
}
throw new Error('rate_limited');
}
4
Set HTTP_PROXY/HTTPS_PROXY/NO_PROXY in the OpenClaw agent runtime, ensure the corporate proxy permits CONNECT to Brave Search hosts and provides proxy auth if required, import the corporate CA into the container/VM trust store and point the runtime (SSL_CERT_FILE or NODE_EXTRA_CA_CERTS) to it, raise client TLS timeouts, and only disable verification temporarily for debugging.
// Node example: use corporate CA and set timeout
const fs = require('fs');
const https = require('https');
const axios = require('axios');
const ca = fs.readFileSync(process.env.SSL_CERT_FILE || '/etc/ssl/certs/corp-ca.pem'); // load CA
const agent = new https.Agent({ ca, keepAlive: true });
axios.get('https://search.brave.com/', { httpsAgent: agent, timeout: 20000 }) // set timeout
.then(r => console.log(r.status))
.catch(e => console.error(e.message));
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.
