Skip to main contentSkip to content

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.

Rule-based coverage engine Multi-carrier routing Public REST API Built & tested in-house

Try the Monster Lab 🧪 Talk to us

20+coverage lines classified
560+rule signals in the engine
100%deterministic — no black box
Every deployautomated tests run

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.

The Monster Lab coverage engine returning matched coverages and a risk read for a described risk
A live result from the Monster Lab coverage engine.

Try the Monster Lab live →

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.

Node.js
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);
PHP
$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:

Node.js / Express
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();
});
PHP
$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.

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.

On the roadmap

Self-Serve Partner Portal

A self-serve portal and SDKs on top of the now-live classification API, authenticated keys, and signed event webhooks.

On the roadmap

Deeper Ops Automation

More automation in the operations layer — status, follow-up, and reporting on top of the existing intake pipeline.

On the roadmap

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
Call Us Get a Quote