Launching OpenPartner: open-source attribution that doesn't lock you in

If you’ve ever set up a partner or affiliate program, you’ve probably had this conversation with yourself:

“I just need to track when someone clicks a partner’s link and ends up paying us. How is this $400/month?”

And then you start looking, and the answer is some combination of:

• Click trackers (Dub, Tolt, the link-shortener tier) — they nail the click side but stop there. Once a customer leaves the link, you’re on your own to figure out who paid and how much.
• Enterprise attribution (Impact, Partnerize, CJ, Rakuten) — they handle the full chain but they’re expensive, configured by their CSM team, and your attribution data lives inside their platform forever. Migrating off is a six-month project.
• DIY — a Postgres table called referrals, a manual reconciliation cron, and a slow drift toward chaos as you grow past 20 partners.

We’ve shipped the second of those for SaaS companies before, and helped friends implement the third. None of them feel right for the small-to-mid SaaS or creator-economy brand that just wants partners to be a real channel without becoming a vendor-lock-in story.

So we built OpenPartner as the thing we kept wishing existed. It’s open source, MIT-licensed, and shipping today.

What it does

The full chain, end to end:

clicks  →  identities  →  events  →  attributions  →  payouts
(raw)     (stitched)     (raw)      (derived)        (Stripe Connect)

• A click router built on Hono that 302-redirects partner share-links and stamps a first-party _cref cookie (90-day TTL by default). The cookie lands on your domain via the redirect, so Safari ITP doesn’t strip it the way a third-party tracker would. Ships as a Node service today; the Hono base means an edge port (Cloudflare Workers, Deno) is a config change rather than a rewrite.
• Identity stitching that ties a click to a logged-in user when they sign up or sign in with an active _cref (cookie or URL param). The /identify endpoint takes a userId + cref pair, writes an Identity row, and back-attributes any prior Event rows the user already had — so the cross-device case (clicked on phone, signed up later on laptop) works as long as both sessions reach the SDK with the same cref.
• Event ingestion for signup, trial_started, subscription_created, invoice_paid, and custom types via a TypeScript SDK.
• Four attribution models — last-click, first-click, linear, position — all implemented and selectable per Campaign. The data shape is derivation-friendly: Click + Identity + Event rows are immutable, the Attribution table is computed from them. Today, changing a Campaign’s model only affects events that arrive after the change; back-filling past Attribution rows under a new model is on the roadmap, not shipped. We’re treating it like the rest of the platform — get the foundation right first, surface the controls when they’re real.
• Commissions + payouts through Stripe Connect Standard accounts. Per-program holdback days matched to your refund window so partners don’t get paid on conversions that refund a week later.
• A creator marketplace (the “Network”) where brands publish offerings and creators apply. Optional — you can run a closed roster if you prefer.

Three pricing tiers, pick at signup

The other thing we wanted to fix is that affiliate platforms force you into their commercial model whether it fits or not. So we did three:

1. Self-host (free). Drop-in Docker Compose, runs on your infra, you own the data. The full product, no nag screens, no feature gates. We built it this way because that’s what we’d want to use.
2. Hosted flat-fee. Same codebase on our infra, predictable monthly subscription. Good fit for brands that don’t want to run Postgres + Stripe webhooks + a click router themselves.
3. Hosted revenue-share (3%). No monthly fee; we take 3% of attributed GMV. Good fit for brands testing whether partner attribution actually works for them — pay nothing until conversions show up.

Pick at signup, switch later. Pricing is a deployment-time choice, not a product-shape decision.

Data portability is the architecture

Every table has a documented schema, every row is exportable to CSV + JSON + SQL dump. The self-hosted version reads the same export format the hosted version produces — migrating off is a one-button move, not a vendor-managed project.

This isn’t marketing copy. It’s a hard architectural commitment that constrains what we build:

• Raw data is immutable. Click → identity → event is an event-sourced chain. Attribution + commission rows are computed from those raws, not written by destructive collapse. The architecture supports re-deriving history under a new model; live tooling for the “change model + back-fill past attributions” case is on the roadmap, but the data shape doesn’t need to change to enable it.
• No hosted-only fields on core tables. Anything our hosted tier needs goes in sidecar tables that are clearly optional, so the export from hosted is identical-shape to a self-hosted dump.
• No “your data trains our models” toggle. We don’t ingest customer attribution into a shared pool. Ever. Even if it would make a feature better.

The bet: brands evaluating attribution platforms in 2026 are tired of the lock-in. If “you can leave with your data” is a real promise rather than a section in the ToS, the trust pays for itself.

What’s NOT in v1

Naming the absences honestly so you don’t show up expecting them:

• Not a link shortener. Dub is great at that; we don’t compete.
• Not a CRM. Partner roster is intentionally minimal — name, email, Stripe account, link. Integrate your CRM if you need rich profiles.
• Not a fraud-detection ML platform. Velocity limits + a manual review queue for v1. Enterprise fraud tooling is post-Series-A territory.
• Not a merchant of record. Your Stripe account, your payments, your customers. We facilitate partner payouts only.

If you need any of those, OpenPartner isn’t the right tool. If you’re in the overlap of “I want full attribution” + “I want to control my data” + “I’d rather not pay enterprise prices” — read on.

Try it

• Hosted, 14-day free trial — sign up at app.openpartner.dev
• Self-host quickstart — docs/self-host/compose, one docker compose up, you’re running in under 5 minutes
• Source code — github.com/getcoherence/openpartner (MIT)
• Issues + feedback — the GitHub issue tracker is open

We’re building this as the foundation for a creator-and-brand network that we think can be a genuine alternative to the closed marketplaces. Today’s launch is the platform itself; the network is opt-in and growing. If you’re a brand running affiliate or creator partnerships and you’ve got opinions about what this should do next, we want to hear them.

— The OpenPartner team