Metafinite Docs

What Metafinite does

You give Metafinite a URL. You paste that URL into Stripe, GitHub, or any webhook provider. When a webhook arrives, Metafinite returns HTTP 200 immediately — the provider never times out. Then Metafinite reads the payload, checks it against your routing rule, and either forwards the payload unchanged to your server or drops it at the edge.

Your rule is plain English. 'Forward if payment failed and amount over $40.' You write the thresholds. You set the conditions. If Stripe renames a field next month, your rule still works — the engine reads your intent, not exact field paths.

Every decision is logged with a written reasoning. Every log entry shows what was checked and why the decision was made.

Quickstart

Start intercepting webhooks in under 5 minutes.

curl -X POST https://metafinite.com/endpoints \
  -H "Authorization: Bearer mf_live_YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Stripe High-Value Failures",
    "destination_url": "https://api.yoursite.com/webhooks",
    "rule_text": "forward if status is payment_failed and amount over 1000"
  }'

{
  "endpoint_id": "ep_01abc123def456",
  "proxy_url": "https://metafinite.com/p/ep_01abc123def456",
  "status": "active"
}

Authentication

All management API requests require a Personal Access Token. Generate one at Dashboard → Settings → API Tokens → New Token.

Tokens are SHA-256 hashed before storage. The raw value is shown exactly once on creation.

Authorization: Bearer mf_live_9a8b7c6d5e4f3a2b1c0d9e8f7a6b5c4d3e2f1

Environments

Every endpoint is instantly live on the global edge. To test safely: create a second endpoint named "Staging" and point its destination_url to your local ngrok URL.

Architecture

What happens when a webhook hits your proxy URL:

1. 1.Provider sends POST to https://metafinite.com/p/{endpoint_id}
2. 2.Edge function receives the request
3. 3.200 OK returned immediately (Cloudflare waitUntil) — provider never times out
4. 4.Routing engine evaluates payload against rule_text asynchronously
5. 5.Decision: FORWARD → sent to destination_url | DROP → discarded
6. 6.Decision + reasoning inserted into webhook_logs
7. 7.Supabase Realtime CDC broadcasts the row to dashboard (~1s latency)

Routing Rules

A routing rule is a natural language string evaluated as a boolean: true = FORWARD, false = DROP.

Rule: "amount over 1000"
Payload: { "amount_due": "5000" } → 5000 > 1000 ✓

Rule: "email contains @enterprise.com"
Payload: { "user": { "contact": { "email": "ceo@enterprise.com" } } } → true

Rule: "status is failed"
Payload: { "status": "payment_failed" } → true

"forward if payment failed AND amount over $50 AND customer tier is enterprise"
"drop if event is ping OR event is health_check"

Live Tail

Powered by Supabase Realtime CDC over WebSockets. Events appear within ~1 second — no polling, no refresh.

Each row shows: timestamp, decision (color-coded), written reasoning (expandable), raw payload, destination response status.

POST /endpoints

Requires Bearer token. Creates a new proxy endpoint.

curl -X POST https://metafinite.com/endpoints \
  -H "Authorization: Bearer mf_live_YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Stripe High-Value Failures",
    "destination_url": "https://api.acme.com/v1/webhooks",
    "rule_text": "forward if amount > 1000 and status is payment_failed"
  }'

GET /endpoints

curl -X GET https://metafinite.com/endpoints \
  -H "Authorization: Bearer mf_live_YOUR_TOKEN"

POST /p/{endpoint_id}

No auth required. This is the URL you paste into Stripe, GitHub, etc.

Guide: Stripe Integration

1. 1.Create an endpoint

   curl -X POST https://metafinite.com/endpoints \
     -H "Authorization: Bearer mf_live_YOUR_TOKEN" \
     -d '{"name":"Stripe","destination_url":"https://api.you.com/hooks","rule_text":"forward if payment failed and amount over $50"}'

2. 2.Copy the proxy_url

3. 3.Stripe Dashboard → Developers → Webhooks → Add endpoint → paste proxy_url → select all events

4. 4.Send a test event from Stripe and watch the Live Tail

Guide: GitHub Webhooks

1. 1.Create an endpoint

   curl -X POST https://metafinite.com/endpoints \
     -H "Authorization: Bearer mf_live_YOUR_TOKEN" \
     -d '{"name":"GitHub PRs","destination_url":"https://api.you.com/hooks","rule_text":"forward if pull request opened or merged on main branch"}'

2. 2.GitHub → Repo → Settings → Webhooks → Add webhook → Payload URL: proxy_url → Content type: application/json

Guide: HTTP Clients

The REST API is designed to be called from any HTTP client or CI pipeline. rule_text accepts natural language — no schema mapping needed.

const res = await fetch('https://metafinite.com/endpoints', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${MF_TOKEN}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    name: 'Churn alert',
    destination_url: 'https://api.yoursite.com/alerts',
    rule_text: 'forward if subscription cancelled and customer LTV over $500'
  })
})

Security

Frequently asked questions

MCP Overview

Model Context Protocol (MCP) is an open standard for tool use. Metafinite is MCP-ready today — our REST API accepts plain English routing rules, making it natively compatible with any MCP host.

MCP Server In development

An official Metafinite MCP server — expose Metafinite as a tool with one config line.

{
  "mcpServers": {
    "metafinite": {
      "command": "npx",
      "args": ["metafinite-mcp"],
      "env": { "MF_TOKEN": "mf_live_YOUR_TOKEN" }
    }
  }
}

Sign up at /beta to be notified when it launches.