We Insure Things · Technology
Insurance technology, built in-house.
We're an independent agency that builds our own software — a rule-based coverage engine, multi-carrier routing, and an operations layer — to match people and businesses with the right protection, faster.
What powers We Insure Things
The parts of our stack that are live today.
Rule-Based Coverage Engine
Our Monster Lab maps a plain-English description of almost any risk to the coverages that may apply — plus a risk and placement read and clear next steps. It runs on a deterministic, tested rule engine (no black box), classifying 20+ personal and commercial lines from 560+ signals.
Multi-Carrier Routing
Every request is routed to the right path — a vetted carrier or partner quote flow (auto, home, travel, pet, event, and more) or a licensed agent — so people reach a product that fits instead of a dead end.
Lead & Operations Layer
Submissions flow into a structured intake-and-review pipeline in our admin: captured, categorized, and routed — with conversion event tracking and analytics across the funnel.
See the engine in action
The Monster Lab is live. Describe a thing — a business, an event, a vehicle, or something genuinely weird — and the engine returns the coverages that may matter, a risk read, and where to go next.
Developer API Live
The same coverage engine, available as a JSON REST API. Send a plain-English description of a risk; get back matched coverages, a risk and placement read, and a routing target. Read-only and CORS-enabled. Anonymous use is rate-limited; authenticated partner keys get higher limits (send X-WIT-Key).
POST https://weinsurethings.com/wp-json/wit/v1/classify
curl -X POST 'https://weinsurethings.com/wp-json/wit/v1/classify' \
-H 'Content-Type: application/json' \
-d '{"text":"mobile axe-throwing trailer for events"}'
Coverage catalog: https://weinsurethings.com/wp-json/wit/v1/coverages
Call it from your code
Copy-paste starters. Send an X-WIT-Key header to lift the rate limit from 30 to 300 requests per minute.
const res = await fetch(
'https://weinsurethings.com/wp-json/wit/v1/classify',
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
'X-WIT-Key': process.env.WIT_KEY, // optional: 300/min vs 30/min
},
body: JSON.stringify({ text: 'mobile axe-throwing trailer' }),
}
);
const data = await res.json();
console.log(data.coverages, data.risk, data.route);
$ch = curl_init('https://weinsurethings.com/wp-json/wit/v1/classify');
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => [
'Content-Type: application/json',
'X-WIT-Key: ' . getenv('WIT_KEY'), // optional
],
CURLOPT_POSTFIELDS => json_encode(['text' => 'mobile axe-throwing trailer']),
]);
$data = json_decode(curl_exec($ch), true);
Webhooks
Subscribe to platform events — lead.created, contact.created, wall.created — and receive a signed JSON POST when they happen. Every request carries X-WIT-Signature: sha256=HMAC_SHA256(body, secret) so you can verify authenticity.
Verify every delivery before you trust it — compute the HMAC over the raw request body with your endpoint secret and compare in constant time:
import crypto from 'crypto';
// Use the raw request body (do not re-serialize it).
app.post('/webhooks/wit', express.raw({ type: 'application/json' }), (req, res) => {
const expected =
'sha256=' +
crypto.createHmac('sha256', process.env.WIT_WEBHOOK_SECRET)
.update(req.body)
.digest('hex');
const sig = req.get('X-WIT-Signature') || '';
const ok =
sig.length === expected.length &&
crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected));
if (!ok) return res.status(401).end();
const event = JSON.parse(req.body); // { event, created, data }
// handle event.event and event.data ...
res.status(200).end();
});
$secret = getenv('WIT_WEBHOOK_SECRET');
$body = file_get_contents('php://input');
$sig = $_SERVER['HTTP_X_WIT_SIGNATURE'] ?? '';
$expected = 'sha256=' . hash_hmac('sha256', $body, $secret);
if (! hash_equals($expected, $sig)) {
http_response_code(401);
exit;
}
$event = json_decode($body, true); // ['event' => ..., 'data' => ...]
// handle $event['event'] and $event['data'] ...
http_response_code(200);
More than an engine — the We Insure Things ecosystem
The platform spans the whole journey: we train the agents, build the audience, and give people tools they actually want to use.
Insurance Licensing School 🎓
A free insurance-licensing education platform. We train the next generation of agents on the fundamentals — and the ones who want to keep going join the same tools and carrier network.
learn.weinsurethings.com →WiT Radio 🎙️
Our media arm — insurance made human, on air. Shows, conversations, and community that demystify coverage and feed the top of the funnel.
radio.weinsurethings.com →Consumer Tools 🧪
The front door: the Monster Lab, the "what insurance do I need?" finder, and a set of games and shareable moments that turn a famously boring purchase into something people use — and pass along.
Explore the tools →One company, one stack — education, media, consumer tools, and the coverage engine all reinforce each other.
Where we're headed Roadmap
What we're actively building next. These are in progress, not shipped yet — we'd rather be straight about that.
Self-Serve Partner Portal
A self-serve portal and SDKs on top of the now-live classification API, authenticated keys, and signed event webhooks.
Deeper Ops Automation
More automation in the operations layer — status, follow-up, and reporting on top of the existing intake pipeline.
Self-Serve Tooling
Expanded self-serve tools for the lines we place, building on the Monster Lab and finder.
Building in insurance? Let's talk.
Carrier, MGA, partner, or developer interested in early access to the API — reach out and we'll set up a conversation.
Partner with us Try the Monster Lab