ChatGPT answers, unedited

Yes. If you’re technical, I’d separate the market into true open-source/self-hosted platforms and commercial software that can be deployed on your infrastructure. The first category is surprisingly thin; a lot of “open-source affiliate software” lists are really abandoned GitHub projects or open-source SDKs rather than production systems. refgrow.com

My shortlist

1. RefKit — probably the first one I'd investigate

This is unusually close to what I'd want for a technical SaaS team. It is built around backend/API-based attribution rather than just a JavaScript tracking snippet, supports recurring commissions and payout records, and integrates with Stripe. The project says its application/API is AGPL-3.0, its SDK/CLI/MCP are MIT, and it can be self-hosted with Docker Compose. refkit.net

The architecture is particularly interesting if you already own the billing system:

affiliate link → identify referred user → your checkout → Stripe events → RefKit → recurring commission ledger

That's much nicer than trying to make an affiliate plugin understand your application's subscription state.

I'd put this at #1 for a new SaaS.

2. RefearnApp GitHub

A newer, explicitly self-hostable alternative to Rewardful/FirstPromoter/Tolt. It uses Next.js, Cloudflare Edge, Drizzle and Docker, and is released under AGPL-3.0. It emphasizes high-volume click/conversion tracking and keeping transaction/payout data on your own infrastructure. github.com

I'd investigate this if tracking scale/performance matters more than having the most mature ecosystem.

One caveat: because it's relatively young, I'd inspect the repository's issue activity, tests, release cadence, and especially its handling of subscription cancellation, refunds, chargebacks, retries and attribution changes before putting money through it.

3. Refferq GitHub

Another modern open-source option, built with Next.js/PostgreSQL. It provides an affiliate portal, admin interface, referral/conversion analytics, automated commission calculations, payout processing and email notifications. github.com

This looks more like a complete affiliate application than merely a tracking library.

I'd consider it if you want something you can fork and substantially customize.

4. Weferral GitHub

Interesting if your requirements are relatively straightforward. It explicitly supports:

• recurring/lifetime commissions
• monthly commissions for SaaS
• one-time commissions
• fixed or percentage commissions
• customizable affiliate portals

However, the maintainers explicitly describe it as not production-ready / work in progress, so I wouldn't make it the default choice for a revenue-critical program without doing substantial due diligence. github.com

The non-open-source options I'd still consider

If your definition of "self-hosted" is more important than "OSI-licensed," there are considerably more mature choices.

AffiliateWP is worth considering if you're already on WordPress. It supports recurring referrals through an addon, where subscription renewal payments automatically create affiliate referrals. affiliatewp.com It also has sophisticated payout functionality, including scheduled payouts. affiliatewp.com

The important distinction: it is not actually an open-source/free product. Its public GitHub repository exists primarily for community development, and the project explicitly says a valid commercial license is required for live use. github.com

Solid Affiliate is another good choice if you're specifically a WooCommerce shop. Its native recurring-commission support and subscription integration make it attractive, but it's a commercial WordPress plugin rather than OSS. www.wpallimport.com

Post Affiliate Pro is the other one I'd investigate if you want a mature, broad affiliate-management system and are willing to pay for it. It's self-hostable but proprietary. refgrow.com

What I'd prioritize technically

For a recurring SaaS commission program, I wouldn't choose based primarily on the affiliate dashboard. I'd evaluate the commission ledger and event model.

Specifically, make sure the system can correctly handle:

1. First-touch vs last-touch attribution
2. Affiliate attribution surviving signup → trial → paid conversion
3. Recurring commissions on every invoice/renewal
4. Upgrades/downgrades
5. Cancellations
6. Refunds and chargebacks
7. Failed payments and subsequent recovery
8. Coupons + affiliate links simultaneously
9. Commission caps/durations, e.g. 30% for 12 months
10. Affiliate-specific rates
11. Multiple currencies
12. Idempotent webhook processing
13. A tamper-resistant commission ledger
14. Payout holds/approval periods
15. Fraud/self-referral detection
16. Export/API access to the underlying data

The webhook/event model is the big one. You don't want the affiliate system deciding that someone earned $X merely because a browser landed on /signup. Your billing system should be authoritative:

click
  ↓
affiliate attribution
  ↓
signup
  ↓
customer_id ←→ affiliate_id
  ↓
subscription created
  ↓
Stripe invoice.paid
  ↓
commission ledger entry
  ↓
invoice.paid again
  ↓
recurring commission ledger entry
  ↓
refund / chargeback
  ↓
commission reversal
  ↓
payout

For that reason, I'd start by evaluating RefKit and RefearnApp, then Refferq. If you're already deeply invested in WordPress/WooCommerce, I'd switch that recommendation to AffiliateWP/Solid Affiliate.

One other important observation: "open source" doesn't necessarily mean "economically free." AGPL software is excellent if you want to run and modify it yourself, but you should examine the license implications if you're planning to embed/modify the application and offer it as part of a hosted service.

If you tell me your stack (Stripe/Paddle/Lemon Squeezy, Next.js/Rails/Laravel/etc.) and roughly number of affiliates + monthly transactions, I can narrow this to 2–3 options and compare their architecture, licenses, Stripe/webhook support, recurring commission semantics, and deployment model.

If you’re technical and self-hosting is a real requirement, the field gets surprisingly small. There are plenty of SaaS affiliate platforms, but genuinely open-source, production-ready systems that handle subscription lifecycle + recurring commissions + attribution + affiliate payouts are rare. Refgrow Icodrip

My shortlist

A key distinction: open-source and self-hosted aren't synonymous. Post Affiliate Pro, for example, is self-hostable but proprietary; AffEasy is genuinely open source. Refgrow GitHub

1. AffiliateWP — easiest if you're on WordPress

affiliatewp.com is probably the most polished self-hosted choice if your application is WordPress/WooCommerce.

It supports recurring, lifetime and multi-tier commissions and integrates deeply with WooCommerce, Easy Digital Downloads, memberships, etc. Everything lives in your WordPress installation. Rekomi

I'd choose it if: your billing/application layer is already WordPress.

I wouldn't choose it if: you're running a Rails/Node/Go/Next.js SaaS and merely want to bolt affiliate tracking onto it.

2. Post Affiliate Pro — strongest general-purpose self-hosted option

postaffiliatepro.com is worth serious consideration if you want something more standalone.

It has extensive tracking methods, server-to-server integration, multi-tier capabilities, fraud controls and a large integration ecosystem. It's proprietary rather than open source, but you host the software yourself. Rekomi Refgrow

I'd choose it if: you want mature affiliate infrastructure and don't particularly care about having source code.

The downside is that it has a somewhat dated architecture/UI, and affiliate payments are generally something you manage rather than having a modern Stripe-like automated payout system. Rekomi

3. AffEasy — interesting if "actually open source" matters

github.com is an AGPL-licensed open-source affiliate platform. Its stated goal is to provide an open-source affiliate marketing platform, and it can be self-hosted. GitHub

I'd treat this as a potential foundation rather than an unquestioned production choice, though. The ecosystem and maturity are nowhere near the established proprietary products.

If you're comfortable reading the code and extending it, that's actually potentially attractive.

4. PNLCS — interesting if you're running a hosting/service business

github.com is an open-source, self-hosted WHMCS alternative built with Laravel/MySQL. It includes recurring billing and affiliate tracking alongside customer management, invoicing, provisioning, etc. GitHub

This is more interesting if your business looks like:

customer → subscription/service → recurring invoice → affiliate commission

rather than:

SaaS app → Stripe → affiliate tracking API

In the latter case, I'd build/use something more specialized.

The important part for a SaaS: recurring commissions

If you're selling subscriptions, don't evaluate these systems based merely on whether they say "recurring commissions."

You want the affiliate engine to understand the subscription lifecycle:

affiliate link
     ↓
visitor
     ↓
signup
     ↓
Stripe customer
     ↓
subscription created
     ↓
payment succeeded ──────────────┐
     ↓                         │
commission #1                  │
                               │
payment succeeded              │
     ↓                         │
commission #2                  │
                               │
subscription cancelled ────────┘
     ↓
stop future commissions

Ideally you also want:

• server-side attribution, not just browser cookies
• Stripe/Paddle webhook support
• recurring commission generation from subsequent invoices
• refunds and chargebacks → commission reversals
• subscription upgrades/downgrades
• free trials converting to paid
• coupon attribution
• commission holds/approval periods
• affiliate-specific commission rates
• lifetime vs. fixed-duration commissions
• first-touch vs. last-touch attribution
• fraud/self-referral detection
• immutable commission ledger
• API/webhooks
• manual adjustments
• affiliate payout accounting

That distinction is why I'd be cautious about many of the small GitHub "affiliate" projects: they may solve link tracking, while leaving you to build the actual financial/subscription machinery. The OSS landscape currently has relatively few mature all-in-one implementations. Refgrow

What I'd do in your position

If you're building a non-WordPress SaaS, I'd narrow it to three strategies:

A. Want minimum engineering → Post Affiliate Pro

Use the mature product and integrate your billing system into it.

B. Want source ownership → build a small affiliate service

For a technical team, this can actually be compelling.

I'd make the affiliate system a standalone service:

                ┌───────────────┐
                │   Your SaaS   │
                └───────┬───────┘
                        │
                 Stripe webhooks
                        │
                        ▼
              ┌──────────────────┐
              │ Affiliate service │
              ├──────────────────┤
              │ Attribution       │
              │ Affiliates        │
              │ Commission rules  │
              │ Commission ledger │
              │ Fraud checks      │
              │ Payouts           │
              └────────┬─────────┘
                       │
                 affiliate portal

The key architectural decision is to make the commission ledger event-driven rather than calculating commissions by querying current subscription state.

For example:

invoice.paid
  → identify affiliate
  → calculate commission
  → create commission ledger entry

invoice.refunded
  → identify original commission
  → create reversal ledger entry

That makes recurring commissions, refunds, disputes and audits much easier.

C. Want OSS but don't want to build everything → use an OSS project as the UI/domain layer

This is probably the sweet spot if you're willing to contribute code. Start with something like AffEasy, but make your billing provider the source of truth and integrate it via webhooks rather than trying to make the affiliate software become your billing system.

One thing I would not do

I wouldn't automatically choose a hosted SaaS affiliate platform just because it has better Stripe integration. Products such as Rewardful, FirstPromoter and Tolt are much more purpose-built for SaaS subscriptions, but they're hosted rather than self-hosted. Current comparisons show the SaaS category has considerably better native handling of subscription events and recurring commissions. Icodrip Affitor Documentation

If self-hosting is a hard requirement, I'd rank your starting points:

Non-WordPress SaaS:
Post Affiliate Pro → custom service → AffEasy

WordPress/WooCommerce:
AffiliateWP → custom service

Hosting/service business:
PNLCS

If you tell me your stack (Stripe/Paddle/Lemon Squeezy + Node/Rails/Laravel/etc.) and whether you need affiliate payouts or just commission accounting, I can narrow this to the 2–3 architectures I'd actually deploy.

github.com is an AGPL-licensed open-source affiliate platform. Its stated goal is to provide an open-source affiliate marketing platform, and it can be self-hosted. GitHub

I'd treat this as a potential foundation rather than an unquestioned production choice, though. The ecosystem and maturity are nowhere near the established proprietary products.

If you're comfortable reading the code and extending it, that's actually potentially attractive.

4. PNLCS — interesting if you're running a hosting/service business

github.com is an open-source, self-hosted WHMCS alternative built with Laravel/MySQL. It includes recurring billing and affiliate tracking alongside customer management, invoicing, provisioning, etc. GitHub

This is more interesting if your business looks like:

customer → subscription/service → recurring invoice → affiliate commission

rather than:

SaaS app → Stripe → affiliate tracking API

In the latter case, I'd build/use something more specialized.

The important part for a SaaS: recurring commissions

If you're selling subscriptions, don't evaluate these systems based merely on whether they say "recurring commissions."

You want the affiliate engine to understand the subscription lifecycle:

affiliate link
     ↓
visitor
     ↓
signup
     ↓
Stripe customer
     ↓
subscription created
     ↓
payment succeeded ──────────────┐
     ↓                         │
commission #1                  │
                               │
payment succeeded              │
     ↓                         │
commission #2                  │
                               │
subscription cancelled ────────┘
     ↓
stop future commissions

Ideally you also want:

• server-side attribution, not just browser cookies
• Stripe/Paddle webhook support
• recurring commission generation from subsequent invoices
• refunds and chargebacks → commission reversals
• subscription upgrades/downgrades
• free trials converting to paid
• coupon attribution
• commission holds/approval periods
• affiliate-specific commission rates
• lifetime vs. fixed-duration commissions
• first-touch vs. last-touch attribution
• fraud/self-referral detection
• immutable commission ledger
• API/webhooks
• manual adjustments
• affiliate payout accounting

That distinction is why I'd be cautious about many of the small GitHub "affiliate" projects: they may solve link tracking, while leaving you to build the actual financial/subscription machinery. The OSS landscape currently has relatively few mature all-in-one implementations.

What I'd do in your position

If you mean actually self-hosted/open-source, rather than merely “an affiliate SaaS with an API,” the shortlist is surprisingly small. Most of the well-known SaaS affiliate products—Rewardful, FirstPromoter, Tolt, PartnerStack, etc.—are hosted services. Current comparisons confirm that distinction. docs.affitor.com

My shortlist

1. RefearnApp — the one I'd investigate first

RefearnApp GitHub repository

This is unusually close to what you're asking for: it describes itself as an open-source, self-hostable alternative to Rewardful/FirstPromoter/Tolt, is licensed under AGPL-3.0, and provides Docker-oriented infrastructure. Its stated feature set includes tracking, conversions, payouts, analytics, and high-scale tracking. github.com

For a technical team, the interesting part isn't just "affiliate links." I'd evaluate whether its data model supports:

• subscription → affiliate attribution
• recurring commission generation from every invoice
• upgrades/downgrades
• refunds and chargebacks
• commission reversals/clawbacks
• commission duration, e.g. 20% for 12 months
• lifetime commissions
• different rates by product/plan
• affiliate-specific rates
• coupon/code attribution
• multi-touch vs first/last-touch attribution
• manual commission adjustments
• payout states: pending → approved → paid
• immutable/auditable financial history
• Stripe webhooks/idempotency

Those details matter much more than whether it has a pretty affiliate dashboard.

2. SliceWP — excellent if you're already on WordPress

SliceWP

SliceWP is installed directly into WordPress and supports recurring commissions. Its recurring-commission extension can set renewal rates, recurrence limits, and product/membership-specific rates. It integrates with WooCommerce Subscriptions, Easy Digital Downloads, MemberPress, Paid Memberships Pro, SureCart, and others. slicewp.com

It's self-hosted, but I wouldn't classify the current product as a genuinely open-source SaaS affiliate platform in the same sense as an AGPL project. It's much more compelling if your application is already WordPress-based.

3. Solid Affiliate

This is worth considering if your application is fundamentally WooCommerce. It's specifically built around WooCommerce rather than being general-purpose affiliate infrastructure. breakdance.com

I wouldn't choose it for a custom SaaS stack where you're running something like:

Next.js → API → Stripe → Postgres

In that situation you're likely to spend more time adapting WordPress/WooCommerce concepts than you'd save.

What I'd avoid if self-hosting is a hard requirement

Rewardful, FirstPromoter, Tolt, PartnerStack, Tapfiliate, etc.

They're worth studying for feature requirements, though. For example, recurring commissions and subscription lifecycle handling are core features in the SaaS-oriented products. www.rewardful.com

Rewardful is particularly useful as a reference implementation for the UX you probably want: Stripe-centric attribution, recurring commissions, affiliate portals, and automated payouts. But it is a hosted product, not something you deploy on your infrastructure. affitor.com

The important distinction I'd make

There are really three categories:

A. "I want source code and control"

→ RefearnApp
Potentially the best match.

B. "I want something installed on my server"

→ SliceWP / Solid Affiliate if you're in WordPress.
These are much more mature than most hobbyist open-source affiliate projects.

C. "I want a production-grade affiliate ledger for my custom SaaS"

→ I'd seriously consider building a relatively small affiliate subsystem around your existing billing events rather than adopting a generic affiliate application.

For example:

Stripe
  │
  ├── customer.created
  ├── checkout.session.completed
  ├── invoice.paid
  ├── invoice.payment_failed
  ├── customer.subscription.updated
  └── charge.refunded
           │
           ▼
    Affiliate Event Processor
           │
           ├── attribution
           ├── commission rules
           ├── recurring commissions
           ├── clawbacks
           └── ledger
                   │
                   ▼
              Postgres
              ├── affiliates
              ├── referrals
              ├── customers
              ├── commissions
              ├── commission_events
              └── payouts

That architecture is attractive if you're technical because recurring commissions are fundamentally a billing/ledger problem, not merely a click-tracking problem.

What I'd choose

If I were evaluating this for a technical SaaS today:

1. RefearnApp — first thing I'd PoC.
2. SliceWP — only if the product is WordPress-based.
3. Custom affiliate ledger — if affiliate economics are strategically important and you already have a solid Stripe/event architecture.
4. Hosted Rewardful/FirstPromoter/Tolt — if operational simplicity ultimately beats the self-hosting requirement.

One caveat: RefearnApp is relatively young, so I'd do a code/issue/commit-history audit before trusting it with real commission liabilities. The fact that it is AGPL and self-hostable is attractive, but maturity and correctness of the financial ledger matter more than the license.

If you tell me your stack (e.g. Stripe + Laravel/Node/Rails + Postgres, whether you need multi-tier affiliates, and whether commissions are lifetime vs fixed number of months), I can narrow this down to 2–3 options and compare their architectures/API/webhook models.

If by self-hosted you mean “I can deploy the affiliate system on my own infrastructure and own the data,” the market is surprisingly thin. Truly open-source, production-grade SaaS affiliate platforms with recurring commissions are rare; many things marketed as “open source affiliate software” are either tracking libraries, abandoned projects, or self-hosted-but-proprietary products. refgrow.com

For a technical team, I’d divide the options like this:

1. AffiliateWP — strongest if you're on WordPress

AffiliateWP

This is probably the most straightforward self-hosted choice if your application is WordPress + WooCommerce/Easy Digital Downloads. It runs inside your WordPress installation, owns the affiliate data, and supports recurring commissions through its recurring-referrals functionality. refgrow.comicodrip.com

I'd choose it if: your product already lives in WordPress.

I wouldn't choose it for: a Next.js/Rails/Laravel/custom SaaS. You're effectively adopting WordPress as part of the affiliate infrastructure.

2. Post Affiliate Pro — mature self-hosted option

Post Affiliate Pro

This is worth investigating if you want a much more traditional affiliate-management system: multiple commission structures, multi-tier programs, fraud controls, extensive integrations, etc. It has a self-hosted deployment option, but isn't open source—you license the software. refgrow.com

For someone technical, its attraction is that you don't have to build all the boring operational machinery yourself.

3. PNLCS — interesting if billing is part of the problem

PNLCS GitHub repository

PNLCS is an MIT-licensed, Laravel/MySQL, self-hosted WHMCS alternative. It includes billing, recurring invoicing, customer management, reseller functionality, and affiliate tracking. github.com

It's not what I'd call a general-purpose SaaS affiliate platform yet, but it's interesting if you're building a hosting/infrastructure/service business where billing + affiliate management need to be tightly coupled.

4. Billmora — more of a foundation than an affiliate product

Billmora GitHub repository

Billmora is another open-source Laravel billing platform focused on recurring billing and automated provisioning. github.com

I'd consider this only if you're comfortable extending the application yourself. It could be a useful foundation for a custom referral/commission engine, but I wouldn't select it solely because you need affiliate software.

The option I'd seriously consider: build the commission engine yourself

If you're technical and have a conventional SaaS stack, I actually think this can be more attractive than forcing a generic affiliate product into your architecture.

The hard part isn't generating ?ref=abc123. It's making billing events authoritative.

I'd model it roughly as:

Affiliate
  └── Campaign
       └── Referral
            └── Customer
                 └── Subscription
                      ├── Invoice
                      ├── Refund
                      ├── Upgrade/Downgrade
                      └── Cancellation

Commission
  ├── referral_id
  ├── invoice_id
  ├── affiliate_id
  ├── amount
  ├── rate
  ├── status
  └── payable_at

Then make your billing provider's webhook stream the source of truth:

affiliate click
      ↓
first-party referral ID
      ↓
signup / checkout
      ↓
customer ←→ referral
      ↓
billing webhook
      ↓
commission ledger
      ↓
pending → approved → payable → paid

That gives you some important properties that SaaS affiliate tools sometimes obscure:

• recurring commissions are generated from actual invoices, not browser activity
• upgrades/downgrades can recalculate commission
• refunds can reverse commissions
• churn naturally stops future commissions
• you can implement lifetime vs. fixed-duration commissions
• commission caps are trivial
• multiple affiliates/programs can coexist
• you can make the ledger immutable/auditable
• payout providers become a separate concern

For a technical team, I'd strongly prefer an append-only commission ledger + deterministic calculation rules over putting “affiliate balance” in a mutable row.

What I would not optimize for

Don't make “open source” the primary criterion. The current ecosystem has relatively few genuinely mature OSS options; the research around the space consistently finds that many purported open-source choices are incomplete or unmaintained. refgrow.com

Instead, I'd prioritize:

1. Billing integration — Stripe/Paddle/etc.
2. Webhook correctness + idempotency
3. Recurring commission semantics
4. Refund/clawback handling
5. Attribution model — first-party cookie vs. server-side referral binding
6. Commission ledger/API
7. Affiliate portal
8. Payout workflow
9. Fraud/self-referral detection
10. Data export

For comparison, hosted products such as Rewardful already handle recurring commissions, upgrades, downgrades, cancellations and refunds through Stripe integration. www.rewardful.com So that's roughly the bar I'd want an OSS/self-hosted solution to meet.

My shortlist

If I were evaluating this for a technical SaaS today:

WordPress → AffiliateWP

Need mature turnkey self-hosting → Post Affiliate Pro

Hosting/billing business → PNLCS

Custom SaaS + strong engineering team → build a small commission ledger around your billing webhooks

Want SaaS functionality without operating it → Rewardful / FirstPromoter / Tolt

The last category isn't self-hosted, but it's useful as a benchmark: current SaaS affiliate products have gotten quite good at recurring billing attribution. affitor.com

If you tell me your stack (e.g. Rails/Next.js/Laravel), billing provider (Stripe/Paddle/etc.), and whether you need multi-tier affiliates, I can narrow this down to the 2–3 architectures I'd actually consider and compare their data models/APIs.

Yes. If you’re technical, I’d separate the market into actually open-source/self-hostable versus commercial software you install yourself. The first category is surprisingly thin in 2026. openpartner.dev

My shortlist

\*Check the current licensing/deployment terms before committing.

1. RefearnApp — probably the first one I'd investigate

RefearnApp GitHub repository

RefearnApp is explicitly positioned as an open-source, self-hostable alternative to Rewardful, FirstPromoter and Tolt. It's AGPL-3.0, uses Docker, and is designed around high-scale tracking, real-time analytics and keeping your customer/financial/tracking data on your infrastructure. github.com

For your use case, the interesting part is that it isn't merely a link shortener + conversion counter; it's aimed at affiliate/referral programs for subscription businesses.

I'd choose this if: you're comfortable running Docker/DB/queues yourself and want a reasonably modern SaaS-oriented foundation.

RefearnApp's self-hosting/open-source page

2. OpenPartner — worth evaluating for a more ambitious program

OpenPartner is another MIT-licensed project explicitly targeting modern SaaS affiliate/partner programs, with Stripe-native attribution and self-hosting. openpartner.dev

The MIT license is particularly attractive if you're thinking:

"I may fork this substantially and make the affiliate engine part of our own product."

That's a materially different proposition from AGPL software.

I'd choose this if: permissive licensing and the ability to build your own commercial layer matter more than having the most mature ecosystem today.

3. Weferral — interesting, but I'd treat it as experimental

Weferral GitHub repository

Weferral has a surprisingly relevant feature set: monthly commissions, recurring/lifetime commissions, fixed or percentage commissions, affiliate portals, etc. github.com

The big caveat is straight from the project: it's not production-ready and is still a work in progress. github.com

So I'd use it as something to study/fork, not automatically put in front of affiliates who are expecting accurate money.

4. AffiliateWP — excellent if you're on WordPress

AffiliateWP is self-hosted and has recurring, lifetime and multi-tier commission capabilities, plus deep WooCommerce/EDD integrations. github.comrekomi.comopenpartner.dev

But it's a commercial WordPress plugin, not an open-source SaaS affiliate engine.

If your application is already WordPress/WooCommerce, though, I'd take this very seriously rather than building your own. If you're running Next.js/Rails/etc., it's basically irrelevant. icodrip.com

5. Post Affiliate Pro — the "boring but mature" option

Post Affiliate Pro is much older and isn't genuinely open source in the conventional sense, but it is one of the established self-hostable/commercial options. It supports recurring and multi-tier commissions and has a large integration surface. openpartner.dev

I'd investigate it if you need things like:

• complex attribution rules
• multiple affiliate types
• sub-affiliates / MLM-like tiers
• lots of legacy payment/e-commerce integrations
• mature fraud/tracking functionality

The downside is that its architecture and UX are considerably less attractive if you're building a modern SaaS stack.

The important technical distinction

For recurring commissions, don't evaluate these primarily on whether they can generate an ?ref=foo link.

The hard part is maintaining a correct commission ledger:

click
  ↓
visitor
  ↓
signup
  ↓
customer
  ↓
subscription
  ↓
invoice #1 ──→ commission
invoice #2 ──→ commission
invoice #3 ──→ commission
  ↓
refund/cancellation
  ↓
commission reversal

I'd specifically verify that the software models billing events, rather than simply saying "recurring commissions supported."

For example, you want to know whether it handles:

• upgrades/downgrades
• failed payments
• refunds
• chargebacks
• cancellations
• trials converting to paid
• coupons
• prorated invoices
• multiple subscriptions per customer
• affiliate reassignment
• commission expiration after N months
• lifetime commissions
• pending → approved → payable → paid states
• retroactive corrections
• idempotent webhook processing

That's where a lot of the seemingly attractive open-source projects become less compelling.

What I'd do in your position

I'd shortlist RefearnApp + OpenPartner, then compare them against building a small purpose-built service yourself.

If your requirements are roughly:

Stripe/Paddle subscription → affiliate referral → recurring percentage commission → affiliate dashboard → webhook-driven ledger → payout export

then building it isn't necessarily crazy for a technical team.

I'd make the architecture something like:

Stripe/Paddle
     │
     ▼
Webhook ingestion ──→ immutable billing events
                           │
                           ▼
                    attribution engine
                           │
                           ▼
                    commission ledger
                           │
                    ┌──────┴──────┐
                    ▼             ▼
              affiliate UI    payout system

The immutable event + ledger approach is the bit I'd insist on. Don't calculate "affiliate balance" by repeatedly querying Stripe and multiplying MRR by a percentage. Store the underlying events and commission transactions so you can audit/replay the calculation.

If you tell me your stack (Stripe vs Paddle, language/framework, Docker/K8s, approximate affiliate count and whether you need multi-tier/referral/partner functionality), I can narrow this down to 2–3 viable choices and compare their architecture, license, recurring-commission semantics, APIs/webhooks, and operational burden.

If you’re technical and specifically want self-hosted + open-source + recurring commissions, the field is surprisingly small. A lot of products marketed as “self-hosted alternatives” are actually proprietary SaaS.

My shortlist

\*You'd be implementing the affiliate/commission layer yourself.

1. RefearnApp GitHub — probably the first one I'd test

RefearnApp is explicitly positioned as an open-source/self-hosted alternative to Rewardful, FirstPromoter and Tolt. It's AGPL-3.0, Docker-deployable, uses PostgreSQL, and supports Stripe and Paddle. Its published feature set includes affiliate portals, coupon tracking, analytics and PayPal mass payouts. The repository was updated in July 2026, so it isn't an abandoned OSS project. github.com

The architecture is also reasonably attractive for a technical team:

• Next.js / React
• PostgreSQL + Drizzle
• Docker
• optional Cloudflare Workers for edge tracking
• Stripe/Paddle integrations
• webhook/event-oriented infrastructure

Caveat: only ~25 GitHub stars currently. I'd scrutinize the code, tests, migration strategy, security model and Stripe webhook handling before putting serious commission accounting behind it. github.com

RefearnApp documentation

2. OpenPartner — interesting if you want a more programmable system

OpenPartner describes itself as an MIT-licensed, self-hostable affiliate platform. It supports multiple billing rails including Stripe, Paddle and custom webhooks, attribution models, commission rules and Stripe Connect payouts. openpartner.dev

This is particularly interesting if your requirement isn't merely:

“Stripe subscription → 30% commission every month”

but something more like:

“Affiliate gets 30% for 12 months, reseller gets 20% indefinitely, enterprise referrals use a different attribution model, and upgrades/downgrades/reversals need to recompute commissions.”

I'd put this high on the evaluation list because commission-rule flexibility and event reprocessing matter much more than a pretty affiliate dashboard once you're technical.

One caveat: the strongest claims about the project come from its own site, so I'd inspect the actual repository/activity and license before adopting it.

3. AffiliateWP — very good if you're on WordPress

AffiliateWP is different: it's a commercial WordPress plugin rather than a general-purpose open-source SaaS application. But it is self-hosted, keeps the data in your WordPress installation, and has recurring commissions among its supported commission models. icodrip.com

I'd choose it if your stack is:

WordPress + WooCommerce/Easy Digital Downloads → AffiliateWP

and not if you're running a Next.js/Rails/Django/etc. SaaS.

4. AffEasy GitHub — worth looking at, but I'd rank it lower

AffEasy is AGPL-3.0 and self-hostable, built with TypeScript/Next.js/Prisma and aimed at affiliate marketing/link management. icodrip.comgithub.com

I wouldn't make it my first choice for a serious subscription recurring-commission ledger, though. Its positioning is more affiliate-link/marketing oriented than “subscription billing events become an auditable commission ledger.”

The thing I'd pay the most attention to

For recurring commissions, don't evaluate these primarily by “does it support recurring commissions?”

Instead, inspect their handling of the subscription event lifecycle:

affiliate click
      ↓
signup / checkout
      ↓
subscription.created
      ↓
invoice.paid ──────→ commission
      ↓
invoice.paid ──────→ commission
      ↓
upgrade ────────────→ adjustment?
      ↓
downgrade ──────────→ adjustment?
      ↓
refund ─────────────→ reversal?
      ↓
chargeback ─────────→ reversal?
      ↓
subscription.cancelled

You want the commission system to be event-driven and idempotent, rather than simply calculating:

customer MRR × commission %

every month.

I'd specifically look for:

• Stripe webhook ingestion
• idempotency keys / duplicate-event handling
• immutable commission ledger
• pending → approved → payable → paid states
• refund/chargeback reversals
• subscription upgrade/downgrade handling
• commission duration (12 months, lifetime, etc.)
• commission caps
• multiple commission tiers
• affiliate/customer attribution
• coupon-code attribution
• first-touch vs last-touch
• cookie expiration
• server-side attribution
• historical recomputation
• API/webhooks
• CSV/data export
• payout integration
• fraud controls
• tax/KYC separation from the commission engine

That last point is important: affiliate tracking and affiliate payouts are two different problems. You can have an excellent self-hosted commission engine and still use Stripe Connect/PayPal/Wise/etc. for the actual money movement.

What I'd choose

If I were building a technical SaaS today:

1. RefearnApp → first thing I'd deploy and audit.

2. OpenPartner → strongest candidate if flexible attribution/commission rules and multiple billing providers matter.

3. AffiliateWP → only if WordPress is already your platform.

4. Build it yourself → surprisingly reasonable if your requirements are unusual. I'd make the core a small event-sourced commission service rather than trying to turn an affiliate-marketing package into a billing system.

For comparison, most polished SaaS products such as Rewardful, FirstPromoter and Tolt are hosted proprietary services, despite being much more mature. FirstPromoter, for example, currently emphasizes billing-synchronized recurring commissions and supports multiple subscription billing providers. firstpromoter.com

If you tell me your stack (Stripe vs Paddle, Next.js/Rails/etc., Docker/K8s, expected affiliate count, and whether commissions are lifetime or N-month), I can narrow this to 2–3 viable architectures and compare their actual GitHub/codebases, licenses, deployment requirements, and recurring-commission implementation.

Yes. If you're technical, I’d separate “actually open-source/self-hostable” from the much larger category of hosted affiliate SaaS. For a recurring-revenue program, the shortlist is surprisingly small.

My shortlist

A couple of these deserve special attention.

1. RefRef — probably the first one I'd test

RefRef GitHub repository

RefRef is an AGPL-3.0 referral/affiliate platform with Docker deployment, PostgreSQL, a partner portal, referral attribution, configurable rewards, fraud monitoring, manual/automatic reward approval and reward dispersal. It's currently described as alpha, though, so I'd treat it as a promising foundation rather than blindly putting it in production. github.com

The important architectural advantage for you is that it's a reasonably conventional modern TypeScript/Postgres application—you can inspect and modify the commission engine rather than integrating around a black box.

2. RefearnApp — strongest match for SaaS subscriptions

RefearnApp GitHub repository

This is particularly interesting because it explicitly targets the Rewardful/FirstPromoter/Tolt use case and advertises Stripe and Paddle integration, advanced analytics, affiliate portals, PayPal mass payouts, PostgreSQL, Docker, and Cloudflare-based edge tracking. It's AGPL-3.0 and says self-hosted users get the full feature set. github.com

For your use case, I'd put this near the top if your billing is Stripe/Paddle.

The caveat: it's a relatively young project. I'd inspect the webhook/event model and tests before trusting it with a material commission liability.

3. Refferq — attractive if you want MIT

Refferq GitHub repository

Refferq is MIT-licensed and built specifically as an affiliate-management platform for SaaS. It has affiliate and admin portals, referral tracking, flexible percentage/fixed commissions, payout scheduling, automated commission calculations, and Stripe integration. Its stack is Next.js + TypeScript + PostgreSQL + Prisma. github.com

The GitHub organization shows activity as recently as May 2026, which is encouraging for an OSS project. github.com

I'd choose this over an AGPL project if you're planning to embed/fork the software into a proprietary product and the MIT terms are strategically important.

4. Weferral — specifically interesting for recurring billing

Weferral GitHub repository

Its feature list explicitly calls out:

• recurring/lifetime commissions
• monthly commissions for subscription/SaaS
• fixed or percentage commissions
• affiliate portal customization

That's unusually aligned with your requirement. The big warning is that the maintainers explicitly say it's not production-ready and is a work in progress. github.com

I'd look at its commission implementation for ideas, but probably wouldn't make it the production choice without substantial hardening.

5. Raider — good if you want to build the missing pieces

Raider GitHub repository

Raider is older and much narrower. It provides a self-service affiliate dashboard, tracking-code generation, affiliate balances and payout requests, plus an API through which your backend reports referred payments. It's written in Rust and uses MySQL. github.com

That last characteristic can actually be useful for a technical team:

Your application
      │
      ├── Stripe/Paddle/etc.
      │
      ├── subscription lifecycle
      │
      ▼
Your commission service
      │
      ├── attribution
      ├── recurring commission ledger
      ├── refunds / chargebacks
      ├── clawbacks
      └── commission rules
              │
              ▼
           Raider
       affiliate portal
       tracking + balances
       payout requests

You retain complete control of the actual recurring-commission accounting.

Don't overlook Post Affiliate Pro

It's not open source in the conventional sense, but it is self-hostable/source-available, and unlike many GitHub projects it's a mature commercial affiliate system. Current comparisons describe it as an older platform with a self-host SKU and recurring-commission functionality. openpartner.devopenpartner.dev

If your requirement is actually:

"I want this running reliably next month and don't care whether I can fork the source"

I'd seriously evaluate it alongside the OSS projects.

The feature I'd scrutinize hardest: recurring commission accounting

Don't just look for a checkbox saying “recurring commissions.”

For a SaaS program, you want an explicit event/ledger model something like:

affiliate
   │
   └── attribution
          │
          └── customer
                 │
                 └── subscription
                       ├── invoice.paid
                       ├── invoice.paid
                       ├── invoice.paid
                       ├── refund
                       ├── chargeback
                       ├── upgrade
                       ├── downgrade
                       └── cancellation

And commissions should be derived from those events:

$100 subscription
    × 30% affiliate rate
    = $30 commission

next month
    $120 subscription
    × 30%
    = $36 commission

rather than simply creating a $30 commission when the initial signup occurs.

I'd specifically test whether each candidate supports:

• recurring percentage commissions
• fixed recurring commissions
• commission duration (12 months, lifetime, etc.)
• upgrades/downgrades
• prorations
• refunds
• chargebacks
• failed invoices
• cancellations
• trials → paid conversion
• multiple subscriptions per customer
• affiliate reassignment
• cookie expiration vs. customer-level attribution
• coupon-based attribution
• manual commission adjustments
• immutable/auditable commission ledger
• webhook idempotency
• backfilling missed billing events

That last group is more important than the affiliate dashboard.

My ranking for a technical SaaS team

I'd investigate them in this order:

1. RefearnApp — if Stripe/Paddle + modern SaaS architecture is the priority.
2. RefRef — if you want a genuinely hackable OSS foundation.
3. Refferq — especially compelling if MIT licensing matters.
4. Post Affiliate Pro — if production maturity outweighs source availability.
5. Weferral — interesting implementation/reference, but I'd hesitate to run it unchanged.
6. Raider — good if you're comfortable owning the business logic yourself.

There is a real caveat here: the open-source affiliate-management ecosystem is still immature in 2026. Current surveys of the space find very few maintained projects; several things that appear in search results are either abandoned, merely affiliate-link managers, or referral systems rather than production-grade recurring-commission ledgers. openpartner.dev

If you tell me your billing stack (Stripe/Paddle/Lemon Squeezy/custom), expected affiliate volume, commission rules (e.g. 30% recurring for 12 months), and whether you need automated payouts, I can narrow this to 2–3 and compare their actual architecture/API/database models rather than just their feature pages.

Yes. If you’re technical, I’d focus on actual self-hostable/open-source systems, not the many “affiliate platforms” that merely offer an API.

The field is surprisingly thin in 2026. A few projects are worth evaluating:

1. RefearnApp — my first choice

For a technical SaaS team, this is probably the closest match to what you're describing.

It is AGPL-3.0, self-hostable, Docker-based, and uses PostgreSQL. Its architecture is Next.js/TypeScript + Drizzle + PostgreSQL, with Cloudflare Workers for tracking. It supports Stripe and Paddle, coupon attribution, affiliate portals, payouts, and configurable commission durations. github.comrefearnapp.com

Most importantly for you, its commission model explicitly supports recurring subscription commissions, including configurable durations such as a fixed number of months or lifetime. github.comrefearnapp.com

GitHub repository

Why I'd investigate it first: the stack is modern and hackable, and you can actually inspect/modify the attribution and commission logic rather than treating it as a black box.

One caveat: it's a relatively young project (the GitHub repo currently shows only ~25 stars), so I'd audit the code, issue tracker, deployment process, and database/commission semantics before putting substantial affiliate liabilities through it. github.com

2. Numok — particularly interesting if you're Stripe-only

Numok is explicitly an open-source affiliate platform built around Stripe. It provides tracking, attribution, commission calculation, affiliate portals and payout queuing, and has a Docker deployment path. www.numok.com

Numok website

Numok source repository

I'd put it on a test server and specifically test:

• subscription renewal → commission
• upgrade/downgrade → commission adjustment
• cancellation/refund → clawback
• failed payment → commission behavior
• affiliate reassignment
• attribution expiration
• duplicate Stripe webhook delivery
• delayed/out-of-order webhook events

The important question isn't merely “does it say recurring commissions?” but whether the commission ledger remains correct when the subscription lifecycle gets messy.

3. Weferral — useful, but I'd treat it as an engineering project

Weferral is one of the older-looking open-source projects in this space. Its README explicitly supports monthly commissions for SaaS subscriptions and recurring/lifetime commissions, along with a REST API, webhooks, affiliate dashboard and PostgreSQL. github.com

Weferral on GitHub

The big problem is that the maintainers themselves say it is “not production ready yet” and a work in progress. github.com

So I'd consider it if your goal is:

“I want a starting point I can fork and turn into exactly what my business needs.”

I would not choose it if your goal is:

“I need affiliate partners receiving real money next month.”

4. OpenPartner — interesting newer entrant

OpenPartner is another genuinely open-source/self-hostable approach. Its current feature set is unusually ambitious: MIT-licensed core, multiple attribution models, re-derivation from raw events, Stripe/Paddle/custom billing webhooks, compound commission rules, Stripe Connect payouts and a partner marketplace. openpartner.dev

OpenPartner

I'd investigate this one if you're building something more sophisticated than “affiliate gets 30% of subscription revenue,” particularly if you want:

• multiple commission rules
• multi-sided incentives
• multiple payment processors
• a partner marketplace
• auditable attribution
• the ability to recompute commissions from immutable events

That re-derivation from raw events is especially attractive technically. For affiliate software, I'd much rather have an event ledger from which commission state can be reconstructed than a system where the calculated commission is effectively the source of truth.

What I'd prioritize technically

For recurring SaaS commissions, I'd rank the architecture roughly like this:

1. Immutable billing-event ledger
Store the underlying Stripe/Paddle events rather than only the resulting commission.

2. Deterministic attribution
You want something like:

click → visitor → signup → customer → subscription → affiliate

with stable IDs throughout.

3. A proper commission ledger

Instead of:

affiliate.balance = affiliate.balance + $30

prefer something conceptually like:

commission_event
  customer_id
  subscription_id
  affiliate_id
  source_event_id
  billing_period
  gross_amount
  commission_amount
  status
  rule_version

That makes refunds, disputes, upgrades and recomputation manageable.

4. Idempotent webhook processing

This is critical. Stripe can deliver events more than once, and events aren't something I'd blindly treat as a perfectly ordered stream.

5. Explicit subscription lifecycle semantics

Define what happens for:

new subscription
renewal
upgrade
downgrade
pause
resume
failed payment
past_due
cancellation
refund
chargeback
affiliate reassignment

before choosing the software.

6. Commission duration as data, not hardcoded behavior

For example:

commission_rate = 30%
commission_duration = lifetime

or:

commission_rate = 25%
commission_duration = 12 months

or:

commission_rate = 40%
commission_duration = first 3 invoices

That is much more useful than merely having a boolean recurring=true.

My shortlist

If I were building a technical SaaS today, I'd evaluate them in this order:

🥇 RefearnApp — best starting point for a conventional Stripe/Paddle SaaS affiliate program.
🥈 OpenPartner — most interesting if you want sophisticated attribution/commission logic and potentially a partner marketplace.
🥉 Numok — compelling if you're Stripe-centric and want something relatively focused.
🛠 Weferral — potentially useful as a fork/reference implementation, but not where I'd put production money without substantial work.

And I'd keep the affiliate accounting/commission ledger under your control even if you eventually replace the UI/tracking layer. That's the part that becomes painful to migrate once affiliates have years of recurring commissions attached to customers.

If you tell me your stack (e.g. Stripe + Next.js + Postgres, Paddle, Lemon Squeezy, Chargebee, etc.) and whether you need lifetime vs X-month recurring commissions, I can narrow this down to the 1–2 I'd actually deploy and compare their architectures/codebases.

If you’re technical and specifically want self-hosted + recurring commissions, the shortlist is much smaller than the usual “affiliate software” lists. Most mature SaaS affiliate products are hosted-only. openpartner.devwww.idevaffiliate.com

My shortlist

\*Verify the exact repository/license before adopting; the open-source ecosystem is changing quickly.

1. OpenPartner — probably the one I'd investigate first

This is unusually close to what you're asking for: an MIT-licensed, self-hostable SaaS affiliate platform with the attribution engine, API, partner portal and commission machinery in the open. Its current architecture uses Postgres, a click router, API, attribution engine and partner/admin portals, with Docker Compose deployment. openpartner.dev

The interesting bit for recurring revenue is that it models raw events separately from derived attribution, rather than treating “signup = commission” as the whole system. It also advertises multiple attribution models and compound commission rules. openpartner.dev

I'd choose it if: you're building a SaaS and want something you can fork/modify rather than merely install.

2. RefearnApp — worth evaluating if you want a very developer-centric stack

RefearnApp's GitHub repository describes it as AGPL-3.0, Docker-based, self-hostable, with real-time tracking, payout management and Stripe webhook handling. github.com

Its stack is particularly interesting for an engineering team: Next.js + Cloudflare Edge + Drizzle + Docker, with an architecture aimed at high-volume tracking. github.com

The downside is maturity: it's a much younger project than the established commercial products. I'd inspect its commit activity, test coverage, migration strategy and Stripe webhook/idempotency implementation before trusting it with a significant commission ledger.

3. Post Affiliate Pro — if “self-hosted” matters more than “open source”

This is the pragmatic option. It isn't genuinely open source, but it has a long history, a self-hosted deployment model, extensive integrations, multi-tier commissions and tracking infrastructure. Current comparisons characterize it as mature but dated. openpartner.devwww.idevaffiliate.com

For a real affiliate network with lots of publishers, postbacks, coupon tracking and complex commission structures, I'd take a serious look at it before assuming a young OSS project is production-ready.

4. iDevAffiliate — another mature self-hosted commercial option

Similar philosophy: not FOSS, but you own/run the installation. It supports server-to-server postbacks, percentage/fixed commissions, multi-tier programs and an affiliate portal. www.nowg.net

I'd consider this if you want something you can deploy and operate yourself without becoming the maintainer of an affiliate platform.

5. SliceWP — only if you're already in WordPress

SliceWP has an explicit recurring-commission extension: you can configure renewal commission rates, recurrence limits, and product-specific recurring rates. It integrates with WooCommerce subscriptions and several membership platforms. slicewp.com

For a conventional SaaS stack, though, I wouldn't introduce WordPress solely for this.

What I'd prioritize technically

For a recurring SaaS affiliate program, don't evaluate these primarily on the affiliate dashboard. The hard part is the commission ledger.

I'd want the system to have:

1. Server-side conversion events — Stripe/Paddle webhooks rather than relying exclusively on browser cookies.
2. An immutable event ledger — clicks, referral identity, signup, subscription creation, invoice paid, refund, cancellation, upgrade/downgrade.
3. Commission state transitions — pending → approved → payable → paid, rather than simply storing $37.50 earned.
4. Recurring billing association — affiliate → customer → subscription, so subsequent invoices can generate commissions.
5. Clawbacks — refunds, chargebacks and cancellations should reverse or adjust commissions.
6. Commission windows — e.g. lifetime, 12 months, first 6 invoices, etc.
7. Idempotent webhook processing — absolutely essential with Stripe/Paddle.
8. Reconciliation — ability to compare the affiliate ledger against your billing provider.
9. Raw attribution data — don't let the software permanently collapse attribution into a single opaque decision.
10. An API/webhook layer so you can make your own billing system the source of truth.

That last point is particularly important. For a technical team, I'd much rather have Postgres + webhooks + a transparent commission engine than a beautiful affiliate portal whose internal accounting is inaccessible.

My ranking for your use case

If you're running a technical SaaS with recurring subscriptions:

OpenPartner → RefearnApp → Post Affiliate Pro → iDevAffiliate

I'd start by POC'ing OpenPartner and RefearnApp, especially if you're comfortable operating Docker/Postgres and potentially contributing code. The OSS space is still immature — one recent survey of the ecosystem found only a handful of credible active projects, with several older projects effectively abandoned. openpartner.devwww.idevaffiliate.com

If you tell me your billing stack (Stripe/Paddle/Chargebee/etc.), expected affiliate volume, commission rules (e.g. 30% lifetime vs 30% for 12 months), and whether you need automated payouts, I can narrow this to 2–3 options and compare their architectures/APIs in much more technical detail.

Yes. If you're technical and self-hosting is a real requirement, the market is surprisingly thin. Most polished SaaS affiliate products are closed-source and hosted-only. As of 2026, I’d narrow the field to a few options rather than looking at the huge list of generic “affiliate software” products. openpartner.dev

My shortlist

1. OpenPartner — probably where I'd start

OpenPartner is the most interesting current option for a technical SaaS team.

It is MIT-licensed, self-hostable with Docker Compose, Stripe-native, and explicitly supports recurring/one-time commissions. Its architecture stores raw clicks/events and derives attribution, which is particularly valuable if you expect to change attribution rules later. openpartner.dev

The interesting technical properties are:

• PostgreSQL-backed event/attribution data
• Docker deployment
• API-first tracking
• Server-side revenue events
• Stripe integration
• recurring commissions
• partner portal
• payouts through Stripe
• ability to self-host the same core as the hosted product openpartner.dev

The raw-event/derived-attribution architecture is something I'd specifically look for. Affiliate systems become painful when the database only stores “affiliate X gets $Y” rather than the underlying click → identity → customer → invoice → commission chain.

OpenPartner's GitHub repository

Caveat: it's relatively young. I'd do a serious code/dependency/audit pass before putting a high-volume program into it.

2. RefearnApp — interesting if you want maximum control

RefearnApp on GitHub is another genuinely self-hostable project. It uses Docker and PostgreSQL-oriented infrastructure and is licensed AGPL-3.0. The project describes itself as an open-source alternative to Rewardful, FirstPromoter and Tolt. github.com

Its architecture is particularly interesting for someone technical:

• Next.js
• Drizzle
• Docker
• PostgreSQL
• optional Cloudflare edge tracking
• first-party tracking
• Stripe integration
• analytics
• commission/payout management github.com

I'd choose this over OpenPartner if AGPL is acceptable and you specifically want to own/modify the infrastructure, rather than caring as much about a polished partner-program product.

The main thing I'd investigate before adopting it is maturity: issue velocity, tests, migration quality, webhook idempotency, and what happens when Stripe sends events out of order.

3. Post Affiliate Pro — the boring but mature choice

Post Affiliate Pro isn't open source, but it deserves consideration because it has been around for a long time and supports self-hosting.

Its recurring-commission implementation is considerably more mature than many OSS projects. It supports recurring commissions on daily/weekly/monthly/etc. schedules, as well as an “accurate” webhook-driven mode tied to subscription IDs. www.postaffiliatepro.com

It also has a large integration surface including Stripe, PayPal, Braintree, Chargebee, Recurly, etc. www.postaffiliatepro.com

I'd pick it if your priorities are:

“I need this thing to handle complicated affiliate-program edge cases and I don't particularly care whether I can fork the source.”

I wouldn't pick it if your primary motivation is open source, modern architecture, or building the system into your own product.

What I would not choose

Reflio is worth knowing about because it frequently appears in searches for OSS affiliate software. It was MIT-licensed and Stripe-focused, but current OSS surveys describe it as effectively abandoned. I wouldn't deploy it for a new production program. openpartner.dev

Likewise, AffiliateWP is attractive if you're entirely inside WordPress/WooCommerce, but it's a paid WordPress plugin rather than the sort of standalone infrastructure you're describing. openpartner.dev

And products such as Rewardful are excellent references for product requirements, but they don't meet your self-hosting requirement. Rewardful does handle recurring commissions, upgrades, downgrades, cancellations and refunds very nicely, so it's useful as a benchmark when evaluating OSS alternatives. www.rewardful.com

The features I'd evaluate very carefully

For a recurring-revenue program, “supports recurring commissions” isn't enough.

I'd test each candidate against this event sequence:

affiliate click
    ↓
visitor identity
    ↓
signup
    ↓
customer
    ↓
subscription
    ↓
invoice #1 → commission
    ↓
invoice #2 → commission
    ↓
upgrade → adjusted commission
    ↓
downgrade → adjusted commission
    ↓
failed payment → ?
    ↓
recovered payment → ?
    ↓
refund → clawback
    ↓
cancellation → stop future commissions

And I'd specifically require:

1. Idempotent webhook processing — Stripe can deliver events more than once.
2. Subscription-level identity — recurring commissions need a durable relationship between the original referral and subscription.
3. Refund/clawback ledger — don't merely delete the commission.
4. Immutable event history — attribution should be reproducible.
5. Commission states — pending → approved → payable → paid → reversed.
6. Commission caps/durations — e.g. 30% for 12 months vs. lifetime.
7. Upgrade/downgrade handling.
8. Cookie + server-side attribution rather than relying exclusively on browser cookies.
9. Fraud/self-referral controls.
10. Export/import — ideally the entire program can be reconstructed from your database.

That last one is disproportionately important. Your affiliate ledger becomes financial history; I would not want it trapped in an opaque SaaS database.

My ranking for your use case

If I were building a technical SaaS today:

1. OpenPartner — best balance of OSS, modern architecture, SaaS/Stripe orientation and actual affiliate-program functionality.

2. RefearnApp — investigate if you want something you can aggressively modify and operate yourself.

3. Post Affiliate Pro — use if maturity and breadth beat the OSS requirement.

4. DIY — only if your commission/attribution model is unusual enough that integrating with an existing engine will cause more pain than building the ledger yourself.

One architectural option I particularly like is self-hosting the affiliate engine but keeping your application as the source of truth for customers/subscriptions, with a clean webhook/event boundary:

Your app / Stripe
       │
       │ subscription + invoice events
       ▼
Affiliate engine
       │
       ├── attribution
       ├── commission ledger
       ├── affiliate portal
       └── payout state

That keeps the affiliate system replaceable instead of making your billing system depend on it.

If you tell me your stack (Stripe/Paddle/Lemon Squeezy/etc., language, Kubernetes vs Docker Compose, and whether you need multi-tier affiliates or just one-level recurring commissions), I can narrow this to the 2–3 architectures I'd actually deploy and compare their GitHub/codebases.

If you’re technical and specifically want self-hosted + open source + recurring commissions, I’d narrow the field considerably. A lot of “affiliate software” lists are really hosted SaaS products, while the genuinely self-hostable options tend to be newer projects.

My shortlist

\* Verify the exact recurring/subscription behavior against your billing provider before putting it into production.

1. OpenPartner — probably the most interesting modern option

OpenPartner is unusually close to what I'd want for a technically sophisticated SaaS: MIT-licensed, self-hostable, with Stripe/Paddle/custom billing webhooks, multiple attribution models, commission rules, and a ledger-oriented architecture. Its authors specifically emphasize being able to re-derive attribution from raw events rather than treating attribution as an irreversible decision. openpartner.devopenpartner.dev

Why I'd investigate it first:

• MIT rather than copyleft
• Self-hosting
• Stripe + Paddle + custom billing
• Recurring/compound commission rules
• Raw-event attribution
• More suitable for building a serious partner infrastructure than a simple referral widget

The main caveat is project maturity: it's a relatively new entrant, so I'd inspect its issue history, tests, migrations, deployment process, and production users before making it the system of record.

2. RefearnApp GitHub repository — strongest “just deploy the app” candidate

RefearnApp is AGPL-3.0 and explicitly designed as a self-hosted alternative to Rewardful/FirstPromoter/Tolt. It has Docker deployment, PostgreSQL, Stripe and Paddle integrations, affiliate portals, analytics, coupon tracking and PayPal mass payouts. github.com

Its architecture is quite modern:

• Next.js/React
• PostgreSQL + Drizzle
• Docker
• Cloudflare Workers for tracking
• Redis/queue infrastructure
• Affiliate dashboard

The repository has 1,394 commits and was updated as recently as July 2026, although it only has around 25 GitHub stars, so I'd consider it promising rather than battle-tested. github.comgithub.comwww.postaffiliatepro.com

I'd choose this over a hosted affiliate SaaS if your priorities are data ownership and customization.

3. Numok — worth testing for Stripe

Numok is explicitly open source/self-hostable and built around Stripe. It handles affiliate tracking, attribution, commission calculation and payout queuing. www.numok.com

This looks attractive if your architecture is basically:

Your SaaS
   │
   ├── Stripe
   │     └── subscription lifecycle
   │
   └── Numok
         ├── click tracking
         ├── attribution
         ├── commissions
         └── affiliate portal

I'd put it behind RefearnApp/OpenPartner for a more complex program, though, particularly if you need multiple billing systems or sophisticated historical attribution.

4. RefRef GitHub repository — interesting but experimental

RefRef is AGPL-3.0, Docker-friendly, and aimed directly at referral/affiliate programs. The repository has substantially more community activity than many of these projects—around 179 stars and 38 forks—but the project explicitly labels itself alpha, with potential breaking changes. github.com

I'd consider it if you're happy to contribute code and potentially fork it.

5. Refferq GitHub organization — MIT and SaaS-oriented

Refferq is another open-source affiliate/referral platform aimed at SaaS. Its main repository is MIT licensed and was still being updated in May 2026. github.com

This is one I'd evaluate by reading the code rather than trusting feature checklists—the ecosystem is young enough that implementation quality matters more than the advertised feature set.

The “boring but serious” option: Post Affiliate Pro

If your definition of self-hosted doesn't require open-source, I'd put Post Affiliate Pro on the shortlist.

It is much more mature than the GitHub projects above and has unusually deep commission functionality. Its recurring commission engine can generate commissions daily, weekly, monthly, quarterly, yearly, or using custom intervals, and it supports multi-tier/split commission structures. www.postaffiliatepro.com

That's important because recurring commissions are deceptively complicated. You don't merely want:

signup → pay affiliate 20%

You eventually encounter:

signup
  ↓
$100/mo subscription
  ↓
20% commission
  ↓
upgrade → $200/mo
  ↓
20% of new amount
  ↓
coupon
  ↓
refund
  ↓
failed payment
  ↓
retry succeeds
  ↓
downgrade
  ↓
cancellation
  ↓
reactivation

A mature platform has already encountered many of these edge cases. Post Affiliate Pro explicitly supports recurring commissions tied to recurring payments and has configurable recurrence behavior. www.postaffiliatepro.com

The tradeoff is that it's proprietary/source-available rather than a conventional OSS project, and its UX/architecture aren't as attractive to a developer building a modern SaaS stack.

What I'd prioritize technically

For a recurring-revenue affiliate system, I'd actually evaluate the products in this order:

1. Billing-event correctness
2. Attribution model
3. Commission ledger
4. Refund/chargeback handling
5. Subscription lifecycle handling
6. Data portability
7. Affiliate portal
8. Payout automation
9. Click tracking/analytics

The first six matter considerably more than having a pretty affiliate dashboard.

In particular, I'd want the system to consume immutable billing events rather than periodically asking Stripe “what subscriptions exist?” Your architecture should ideally look something like:

                ┌──────────────┐
click ─────────►│ Attribution  │
                │    engine    │
                └──────┬───────┘
                       │
                       ▼
                ┌──────────────┐
Stripe webhook ─►│ Event store │
                └──────┬───────┘
                       │
                       ▼
                ┌──────────────┐
                │ Commission   │
                │    ledger    │
                └──────┬───────┘
                       │
             ┌─────────┴─────────┐
             ▼                   ▼
       affiliate UI        payout system

That gives you an auditable answer to “why did affiliate X receive $37.42?”, which becomes extremely valuable once money is involved.

My ranking for a technical team

If you're building a SaaS today:

OpenPartner → best architecture/features to investigate
RefearnApp → best ready-to-deploy OSS candidate
Numok → appealing if you're Stripe-only and want simplicity
RefRef → interesting if you're willing to tolerate alpha software
Refferq → worth code-level evaluation
Post Affiliate Pro → my choice if mature recurring-commission machinery matters more than having an OSS license

One important caveat: the open-source affiliate ecosystem is still surprisingly immature. Recent comparisons note that most established affiliate platforms remain closed-source/hosted, so I'd be cautious about putting a young OSS project directly in charge of your financial ledger without testing webhook idempotency, subscription changes, refunds, retries, and reconciliation yourself. openpartner.devopenpartner.dev

If you tell me Stripe vs Paddle vs Chargebee/etc., your commission model (e.g. 20% lifetime recurring), and whether you need PayPal/Stripe Connect payouts, I can narrow this to 2–3 options and compare their actual architectures/repos in depth.

If you’re technical and self-hosting is a hard requirement, the market is surprisingly thin. Most mature affiliate products are SaaS; the genuinely open-source options tend to be newer and less battle-tested.

For recurring SaaS commissions, I’d shortlist these:

1. Numok

Probably the first one I'd investigate. It explicitly positions itself as open-source, self-hosted affiliate software, with unlimited affiliates and your data staying on your infrastructure. Its demo covers the complete flow from affiliate tracking link → purchase → commission appearing in the affiliate portal. www.numok.com

The important thing I'd verify before adopting it is how it handles subscription lifecycle events: renewals, upgrades/downgrades, refunds, cancellations, and attribution after the initial purchase.

2. RefearnApp

A newer AGPL-licensed self-hosted affiliate platform. It is explicitly aimed at SaaS and integrates with Stripe. refearnapp.com

This one is particularly interesting if you want to inspect/modify the actual attribution engine rather than treating the affiliate platform as a black box.

The architecture described by its developer is also quite sensible for a technical team: client-side click tracking + billing webhooks + server-side attribution, with PostgreSQL and Docker. www.reddit.com

I'd consider it for an early/mid-stage SaaS, but I'd scrutinize its test coverage and production history before putting substantial affiliate liabilities through it.

3. OpenPartner

This is probably the most interesting option if your use case is specifically modern SaaS rather than generic e-commerce affiliate tracking.

It uses an MIT license and is designed around Stripe-native attribution, with self-hosting as an option. Its architecture also emphasizes immutable/raw events so commission calculations can be independently audited. openpartner.dev

That last point matters more than it sounds. With recurring commissions, you really want an append-only-ish event history:

customer.created
subscription.created
subscription.updated
invoice.paid
invoice.refunded
subscription.cancelled

and commissions derived from those events, rather than simply maintaining a mutable affiliate_balance column.

4. Sled

If you're using Polar, Sled is worth a look. It's an open-source AGPL affiliate system specifically built around Polar webhooks and reportedly handles subscription renewals, refunds, affiliate-specific commission overrides, and affiliate dashboards. www.reddit.com

I wouldn't choose it merely because it's open source, though—the Polar-specific architecture is the main reason to investigate it.

5. Post Affiliate Pro

This is the "I want something mature and self-hosted, and I don't actually care whether it's OSI-open-source" choice.

It's not genuinely open source; it is proprietary/source-available software with a self-hosted offering. It has been around for a long time and supports sophisticated affiliate structures, including multi-tier commissions and fraud controls. refgrow.com

For a serious program where affiliate accounting is already significant, I'd actually consider it alongside the OSS alternatives because operational maturity can outweigh license purity.

What I'd prioritize for recurring commissions

Don't evaluate these primarily on "does it track affiliate links?" Almost all of them can do that.

For SaaS, I'd test these cases explicitly:

1. Initial conversion → 30% commission
2. Monthly renewal → another 30%
3. Annual → monthly downgrade
4. Plan upgrade → commission on incremental amount
5. Refund → commission reversal
6. Failed payment → no commission
7. Churn → commissions stop
8. Reactivation months later → define whether commission resumes
9. Coupon + affiliate link simultaneously
10. Affiliate changes ownership/referral after signup
11. Chargeback
12. Affiliate deletion
13. Commission rate changes without rewriting historical commissions
14. Multiple currencies
15. Payout hold period

The really important architectural question is whether the system treats billing events as the source of truth. For recurring programs, I'd strongly prefer that over a system that periodically polls Stripe and tries to reconstruct what happened.

My ranking for a technical SaaS team

If you want truly open source:

1. OpenPartner — strongest conceptual fit for SaaS
2. Numok — promising all-around self-hosted option
3. RefearnApp — attractive if you want something lightweight/customizable
4. Sled — move this to #1 if you're on Polar

If "self-hosted" matters more than open-source licensing:

1. Post Affiliate Pro
2. OpenPartner
3. Numok / RefearnApp

One caveat: the OSS ecosystem here is young. A recent survey of the space describes the mature open-source choices as limited, with several projects being new or effectively abandoned. openpartner.dev So I'd do a GitHub-level diligence pass—commit activity, issues, releases, tests, database migrations, webhook idempotency, and number of real production installations—before betting your affiliate ledger on any of them.

If you tell me Stripe vs Paddle vs Lemon Squeezy vs Polar, and whether you need one-tier or multi-tier commissions, I can narrow this to the 2–3 architectures I'd actually deploy.

Yes. If your requirement is specifically self-hosted + recurring commissions + technical control, the field is surprisingly small. I’d separate the options into true open source and source-available/commercial self-hosted.

My shortlist

\*I'd verify the exact recurring/subscription behavior against the current release before committing.

1. OpenPartner — my first choice

This is probably the most interesting option for a new SaaS where you want the software itself under your control. Its core is MIT-licensed and self-hostable, with Postgres, an attribution engine, API, click router, and affiliate/partner portal. It supports Stripe, Paddle, and custom billing webhooks, and its commission model is designed around recurring SaaS revenue. openpartner.dev

The particularly nice architectural choice is immutable raw events + derived attribution. That matters because you can change attribution rules and re-run the calculation rather than having an opaque historical commission ledger. openpartner.dev

I'd pick this if: you're comfortable running Docker/Postgres and want something you can actually extend.

2. RefearnApp — simpler alternative

RefearnApp is explicitly positioned as a free, open-source, self-hostable affiliate-management platform. It provides an affiliate portal, commission engine, payout management and Stripe webhook handling. refearnapp.com

The tradeoff is maturity/ecosystem. It's considerably newer and smaller than commercial affiliate platforms, so I'd inspect the GitHub activity, issue tracker, tests, deployment process, and upgrade story before putting a large affiliate book on it.

I'd pick this if: you want something relatively small that you can understand/fork rather than a big affiliate-network product.

3. Referrq / Raider

There's a small but growing ecosystem of genuinely open-source affiliate/referral projects. A current 2026 directory lists Referrq (AGPL) for affiliate/referral management and Raider (MPL-2.0) for affiliate tracking, alongside RefEarnApp. opensourcetools.org

I'd treat these as projects worth evaluating rather than automatic production recommendations. For recurring SaaS commissions, the important question isn't merely "does it track referrals?" but whether subscription lifecycle events—renewal, upgrade, downgrade, cancellation, refund—are modeled correctly.

If "self-hosted" matters more than "open source"

iDevAffiliate is much more mature. It's proprietary, but you buy a self-hosted PHP/MySQL version for a one-time fee. It explicitly supports lifetime commissions, recurring commissions, configurable numbers of rebills, multi-tier recruiting, delayed commissions, etc. www.idevaffiliate.com

For a business where "I need this to work reliably and don't care whether the source is FOSS" is the priority, I'd seriously consider it.

AffiliateWP is another option if your stack is WordPress. Its higher tiers include lifetime/recurring commissions, recurring referrals, multi-tier commissions and affiliate dashboards. It's specifically a WordPress plugin, though, so I wouldn't choose it for a standalone SaaS stack. affiliatewp.com

What I'd use for a technical SaaS

If your architecture looks roughly like:

Your SaaS
   │
   ├── Stripe/Paddle
   │       │
   │       └── webhooks
   │
   ▼
Affiliate engine
   │
   ├── click attribution
   ├── customer ↔ affiliate association
   ├── recurring commission ledger
   ├── refunds / chargebacks
   ├── upgrades / downgrades / churn
   └── affiliate portal

I'd rank them:

OpenPartner > RefearnApp > iDevAffiliate

The big thing I'd investigate before deployment is commission accounting. Don't choose based on the existence of an "affiliate dashboard." You want an auditable event/ledger model where, for example:

customer referred
→ subscription $100/mo
→ affiliate earns 30%
→ renewal #2: $100 → $30
→ upgrade: $200 → $60
→ cancellation
→ refund
→ commission reversal

If the software can't deterministically reconstruct that history from billing events, you'll eventually end up maintaining a spreadsheet or writing your own reconciliation system.

Also, don't confuse Rewardful with a self-hosted solution: it has excellent recurring Stripe support and automatically handles upgrades, downgrades and cancellations, but it's a hosted commercial service rather than something you deploy yourself. help.rewardful.com

If you tell me your billing stack (Stripe, Paddle, Lemon Squeezy, Chargebee, custom, etc.) and whether you need multi-tenant affiliate programs, I can narrow this to 2–3 choices and compare their architecture, licenses, Docker/deployment model, APIs, attribution, and recurring-commission handling.

Yes. The important distinction is “open source/self-hostable” vs. “actually good at recurring SaaS commissions.” The open-source market is much thinner than the hosted market, so I’d shortlist these:

1. Numok — probably the first one I'd test

Numok GitHub repository

Numok is specifically positioned as an open-source, self-hosted SaaS affiliate platform built on Stripe, rather than a generic affiliate-link manager. Its public project listing describes it as a “SaaS Affiliate Program on top of Stripe,” and the project is actively maintained. github.comgithub.com

Its site says you get the source code, unlimited affiliates, your own infrastructure/data, affiliate portal, commission configuration and Stripe-based tracking. www.numok.com

I'd choose it if: you're Stripe-centric and want something relatively close to a Rewardful/FirstPromoter replacement without building the whole system.

Watch closely: I'd inspect its implementation of subscription renewals, refunds, chargebacks, upgrades/downgrades, and attribution before putting significant money through it.

2. Refferq — interesting modern MIT option

Refferq on GitHub

Refferq is a newer MIT-licensed affiliate-management platform built with Next.js and PostgreSQL. It has an affiliate portal, admin panel, referral tracking, commission management, analytics, automated workflows and payout scheduling. github.com

This is attractive if you're comfortable with TypeScript and want a conventional web application you can fork and modify.

Strength: MIT is a particularly permissive license for a commercial internal fork.

Caveat: I would not assume that “commission management” means robust subscription-lifecycle commissions. Before selecting it, I'd specifically test:

affiliate click
    ↓
signup
    ↓
trial
    ↓
subscription
    ↓
renewal #1
    ↓
upgrade
    ↓
renewal #2
    ↓
downgrade
    ↓
refund
    ↓
cancellation

That lifecycle is where many otherwise-good affiliate projects fall down.

3. RefearnApp — most interesting if you're infrastructure-minded

RefearnApp GitHub repository

RefearnApp is explicitly positioned as an open-source/self-hostable alternative to Rewardful, FirstPromoter and Tolt. It uses Next.js/React, PostgreSQL/Drizzle, Redis and Cloudflare Workers, and advertises Stripe and Paddle integrations, affiliate portals, analytics, payouts and Docker-based deployment. It's AGPL-3.0. github.com

For a technical operator, the architecture is interesting because tracking is separated from the application layer rather than being just a monolithic dashboard.

I'd investigate this one if:

• you expect substantial tracking volume,
• you want to modify attribution logic,
• you want both Stripe and Paddle,
• you're comfortable operating Redis/Postgres/workers,
• AGPL is acceptable for your deployment model.

I'd still consider it a younger project and do a serious code/security/operational review before using it as the system of record for payouts.

4. AffEasy — useful if attribution infrastructure is the main concern

AffEasy GitHub repository

AffEasy is AGPL-3.0 and self-hostable, built with TypeScript/Next.js/Prisma/Redis. Its emphasis is affiliate-link creation and affiliate-network integration rather than being a complete SaaS subscription commission ledger. github.com

I'd consider it more of a building block than my first choice for a recurring SaaS affiliate program.

The wildcard: build the commission engine yourself

If you're genuinely technical, this may actually be the best long-term architecture.

You don't necessarily need a giant affiliate platform. You need four fairly well-defined pieces:

                ┌──────────────┐
click ────────> │ Attribution  │
                └──────┬───────┘
                       │
                       ▼
                ┌──────────────┐
signup ────────>│ Customer ↔   │
                │ Affiliate    │
                └──────┬───────┘
                       │
Stripe events ────────┤
                       ▼
                ┌──────────────┐
                │ Commission   │
                │ Ledger       │
                └──────┬───────┘
                       │
                       ▼
                ┌──────────────┐
                │ Payouts      │
                └──────────────┘

For the billing side, Lago is an interesting open-source/self-hostable billing foundation, while Kill Bill is a much more mature and highly customizable open-source billing platform. Neither is an affiliate system out of the box, but either can provide a solid event/billing foundation around which you build attribution and commissions. github.com

For a technical team, I'd strongly favor an immutable commission ledger rather than calculating “what this affiliate is owed” from the current Stripe subscription state.

Something like:

CommissionEvent
----------------
id
affiliate_id
customer_id
subscription_id
invoice_id
event_type
gross_amount
commission_rate
commission_amount
currency
status
occurred_at
source_event_id

Then Stripe events become the source of truth:

invoice.paid
invoice.payment_failed
customer.subscription.updated
customer.subscription.deleted
charge.refunded
charge.dispute.created

This makes recurring commissions much easier to reason about and audit.

What I'd pick

For your particular description, my order would be:

1. Numok → if you're Stripe-only and want the shortest path to production.

2. RefearnApp → if you want a more ambitious, hackable platform and don't mind operating it.

3. Refferq → if MIT licensing and a straightforward TypeScript/Postgres stack are particularly attractive.

4. Build your own ledger around Stripe/Lago → if affiliate commissions are financially important enough that you want complete control over attribution and accounting.

One important reality check: Rewardful, FirstPromoter and Tapfiliate are considerably more mature products, but they're hosted rather than self-hosted. They demonstrate what “good” recurring commission handling should look like: Rewardful, for example, adjusts commissions for upgrades, downgrades, cancellations and trials, while FirstPromoter supports lifetime, time-limited and charge-count-based recurring commissions. help.rewardful.com Tapfiliate likewise explicitly supports subscription renewals and lifetime attribution. support.tapfiliate.com

So I'd use those as the behavioral specification when evaluating the open-source projects—not just check whether a README says “recurring commissions.”

If you tell me Stripe vs. Paddle vs. another billing provider, approximate affiliate count/traffic, and whether you need automated PayPal/Wise payouts, I can narrow this to the 2–3 strongest architectures and compare their actual GitHub maturity, licenses, deployment requirements, and recurring-commission implementation.

If you’re technical and want to self-host an affiliate platform for recurring commissions (SaaS-style partner programs, subscriptions, revenue share, lifetime commissions, etc.), the biggest thing to check is whether the software supports recurring attribution + subscription events, not just one-time referral payouts.

Here are the main options worth considering:

Open-source options

Mautic + custom affiliate tracking

A common engineering approach is to avoid traditional affiliate software and build the referral ledger yourself:

• Store referral relationships:
  • affiliate_id
  • customer_id
  • first-touch / last-touch attribution
  • campaign/source
• Listen to billing events:
  • Stripe invoice.paid
  • subscription.created
  • subscription.updated
  • subscription.deleted
• Generate commission ledger entries:
  • month
  • MRR amount
  • commission percentage
  • payout status

Pros:

• True recurring SaaS logic
• Handles upgrades/downgrades/cancellations
• Easier compliance/audit trail

Cons:

• You own payout workflows, fraud checks, dashboards

Solidus ecosystem

If you already run Rails commerce, this can be extended into an affiliate/referral system. It is not a drop-in affiliate SaaS product, but it gives you a strong foundation.

Self-hosted commercial products

Post Affiliate Pro

Probably one of the closest matches if you want a turnkey system.

Good at:

• recurring commissions
• multiple commission types
• coupons
• lifetime commissions
• partner portals
• fraud controls
• API integrations

Downside:

• proprietary
• licensing cost

OSI Affiliate Software

A smaller self-hosted option.

Good for:

• SaaS referrals
• reseller programs
• coupon-based attribution
• recurring commissions

AffiliateWP

Best if your product is already WordPress-based:

Works well with:

• WooCommerce subscriptions
• membership sites
• LMS platforms

Less ideal if your SaaS is:

• Stripe-only
• custom backend
• non-WordPress

What I would evaluate for a SaaS recurring program

Before choosing, verify these features:

Billing integration

Must support:

• Stripe subscriptions
• Paddle
• Chargebee
• Recurly
• custom webhooks

Commission model

Look for:

• Lifetime commission

Affiliate earns 20% of every future payment.

• Recurring for N months

Affiliate earns 30% for first 12 billing cycles.

• MRR share

Affiliate earns based on active recurring revenue.

• Tiered commissions

20% standard, 30% for enterprise partners.

Accounting/audit

Important at scale:

• immutable commission ledger
• payout history
• reversals/refunds
• tax forms/export
• manual adjustments

If I were building a technical SaaS today

I’d usually choose one of these:

Fastest path

Post Affiliate Pro + Stripe webhook integration

WordPress SaaS

AffiliateWP + subscription integration

Engineering-first SaaS

Build a small internal affiliate service:

Stack example:

• PostgreSQL
• Stripe webhooks
• Redis queue
• Rails/Laravel/Node API
• admin dashboard
• payout export

The core model is surprisingly small:

Affiliate
  id
  code
  commission_rate

Referral
  affiliate_id
  customer_id
  created_at

SubscriptionEvent
  customer_id
  event_type
  amount

CommissionLedger
  affiliate_id
  invoice_id
  amount
  status

For a serious recurring-revenue SaaS, the custom ledger approach often ends up cleaner than adapting affiliate software designed around one-time ecommerce transactions.

If you’re technical and want to run your own recurring-commission affiliate program (especially for SaaS subscriptions), you’ll want software that can handle:

• recurring revenue attribution (monthly/annual renewals)
• lifetime commissions or tiered commissions
• affiliate portals
• tracking links/cookies
• payouts and tax workflows
• API/webhooks
• fraud controls
• integrations with Stripe, Paddle, Chargebee, etc.

The open-source/self-hosted ecosystem is smaller than the SaaS affiliate space, but these are the main options worth evaluating.

More genuinely open-source candidates

PostAffiliatePro Open Source alternatives / legacy affiliate scripts

There are older PHP affiliate platforms on GitHub (often forks of abandoned scripts), but many have issues:

• weak security posture
• outdated PHP dependencies
• no modern webhook/event model
• poor recurring billing support

They can work as a base, but you’ll likely spend more time modernizing them than building.

Build around an open-source referral engine

For a technical SaaS, many teams build a small affiliate layer instead of adopting a full affiliate platform:

Core tables

affiliates
- id
- payout_email
- commission_rate

referrals
- affiliate_id
- customer_id
- created_at

subscriptions
- customer_id
- stripe_subscription_id
- status

commissions
- referral_id
- invoice_id
- amount
- status

Flow

1. Affiliate link:

yourapp.com/signup?ref=alice

2. Store referral attribution:

customer.metadata.affiliate_id = alice

3. Stripe webhook:

invoice.paid
customer.subscription.updated
customer.subscription.deleted

4. Generate commissions:

invoice.amount_paid * affiliate.rate

5. Affiliate dashboard reads commission ledger.

For recurring SaaS commissions, this architecture is often cleaner than adapting ecommerce affiliate software.

Self-hosted commercial options I’d shortlist

1. Post Affiliate Pro

Best if you want:

• mature tracking
• many affiliate features out of the box
• less engineering work

Weakness:

• proprietary
• customization can be constrained

2. OSI Affiliate Software

Best if:

• you want a classic affiliate platform
• you’re comfortable modifying PHP

3. Custom service + Stripe webhooks

Best if:

• you run SaaS
• commissions are core business logic
• you need unusual rules:
  • 30% lifetime recurring
  • first-year only
  • partner tiers
  • usage-based commissions
  • clawbacks

If I were designing a SaaS affiliate system today

I’d probably avoid a full affiliate CMS and build:

• Stripe Billing → source of truth for revenue
• Postgres → commission ledger
• Redis/queue → async processing
• Your app auth → affiliate dashboard
• Metabase/Grafana → internal reporting

Useful open-source components:

• Supabase for Postgres/auth/storage
• n8n for workflow automation
• Plausible Analytics for privacy-friendly analytics

You end up with something closer to an internal version of Rewardful or FirstPromoter, but fully under your control.

My shortlist by scenario

You want to launch quickly
→ Post Affiliate Pro / OSI

You run WordPress memberships
→ AffiliateWP

You run a SaaS with Stripe
→ Build a small custom affiliate ledger

You need enterprise partner management
→ Evaluate commercial self-hosted platforms rather than FOSS

For a technical SaaS company, I’d lean toward a custom Stripe-driven commission engine unless you need a large marketplace-style affiliate ecosystem.

If you're comfortable operating your own infrastructure and want recurring commissions (SaaS subscriptions, memberships, etc.), the landscape is surprisingly sparse. Most mature affiliate platforms are SaaS. Among self-hosted options, I'd separate them into three groups:

1. OpenPartner (most interesting if you want open source)

Pros:

• MIT licensed
• Self-hostable
• Designed around subscription SaaS
• Raw event model rather than opaque attribution
• Modern architecture
• Handles recurring billing events via webhooks rather than scheduled jobs openpartner.dev

Things I'd verify before adopting:

• Contributor activity
• Upgrade path
• Database migration strategy
• Test coverage
• Production deployments

If I were starting a greenfield SaaS today and wanted an open-source base, this is probably the first repository I'd inspect.

2. RefearnApp

Also open source and self-hostable.

Pros:

• AGPL
• Docker deployment
• Stripe integration
• Lightweight
• Easy to fork

Cons:

• Much younger ecosystem
• Smaller feature set
• Fewer integrations
• Less battle-tested refearnapp.com

Good if you're happy extending the code yourself.

3. Post Affiliate Pro

This has existed for years.

Pros:

• Self-hosted license
• Very complete feature set
• Multi-tier commissions
• Fraud detection
• Recurring commission engine
• Lots of payment gateway integrations

Cons:

• Proprietary
• PHP
• UI shows its age
• Subscription support feels more like an extension than a core design openpartner.devwww.postaffiliatepro.com

If your priority is "works today" over "modern codebase," it's still one of the strongest self-hosted choices.

If you're technical: consider building the attribution layer yourself

Recurring affiliate tracking is mostly an event-processing problem.

A robust architecture looks like:

Affiliate Link
      │
      ▼
Click service
      │
      ▼
Attribution DB
      │
Checkout
      │
      ▼
Billing Provider
(Stripe/Paddle/Lemon Squeezy)
      │
Webhook
      ▼
Commission Engine
      │
      ▼
Ledger
      │
      ▼
Payout Export

Your commission engine consumes events like:

• subscription.created
• invoice.paid
• subscription.updated
• subscription.canceled
• refund.created

instead of trying to infer recurring payments later.

This makes upgrades, downgrades, pauses, refunds, and churn straightforward.

Features I'd insist on

For recurring SaaS commissions, look for:

• immutable commission ledger
• webhook-driven recurring events
• idempotent webhook processing
• affiliate overrides
• first-touch/last-touch attribution
• coupon attribution
• referral-link attribution
• refund reversals
• commission locking
• payout batches
• API-first architecture
• audit trail
• PostgreSQL support

What I'd avoid

Older affiliate software often relies on cron-generated recurring commissions ("generate monthly commissions until canceled"). That works, but webhook-driven commission generation tied to actual subscription events is generally more accurate because it naturally handles failed renewals, pauses, refunds, and plan changes. openpartner.devwww.postaffiliatepro.com

My short list

If I were evaluating today as an engineer:

1. OpenPartner — first repository I'd inspect.
2. Post Affiliate Pro — if you want mature, feature-complete software and don't require open source.
3. RefearnApp — promising lightweight OSS if you're willing to contribute code.
4. Build your own if you already have an event-driven billing backend and want complete control over attribution, commission rules, and payouts.

If your SaaS uses Stripe, Paddle, Lemon Squeezy, Polar, Chargebee, or another billing platform, I can narrow the recommendations further because the webhook and subscription model compatibility is often the deciding factor.

If you're comfortable self-hosting and want recurring commissions (e.g. for SaaS subscriptions or memberships), your options fall into three buckets:

The challenge is that truly open-source affiliate platforms are surprisingly rare, especially those supporting recurring commissions.

Best open-source choices

1. Django Referral System (various projects)

There are several Django- and Laravel-based referral projects on GitHub, but most provide:

• referral links
• click tracking
• signup attribution

and do not include:

• recurring payouts
• commission approval workflows
• payment exports
• fraud detection

These are better starting points than complete affiliate systems.

2. Mautic

Not an affiliate platform, but can be extended.

Pros

• completely open source
• webhook support
• API
• campaign automation

Cons

• you'll build commission logic yourself.

3. Build around FOSSBilling

If you're selling subscriptions, this is actually one of the more interesting approaches.

Architecture:

Customer
   ↓
Affiliate Link
   ↓
Landing Page
   ↓
FOSSBilling
   ↓
Subscription Renewals
   ↓
Commission Engine

You'd implement recurring commission calculations through hooks or webhooks.

Best self-hosted commercial solutions

If open source isn't a hard requirement, these are much stronger.

Post Affiliate Pro

Probably the most feature-complete.

Supports

• recurring commissions
• lifetime commissions
• coupon attribution
• multi-tier affiliates
• API
• webhooks
• Stripe
• Paddle
• WooCommerce
• Magento
• custom integrations

Runs on your own server.

iDevAffiliate

Very mature.

Features

• recurring payouts
• commission tiers
• REST API
• custom commission rules
• fraud detection
• PayPal mass pay
• Stripe integrations

Good if you want something stable that requires little custom development.

AffiliateWP

Excellent if your SaaS uses WordPress.

Supports recurring commissions with supported subscription plugins.

If you're building your own

Many technical founders now build a lightweight affiliate service because the core logic isn't very large.

Typical stack:

• PostgreSQL
• Go / Rust / Node
• Stripe webhooks
• Redis
• ClickHouse for analytics

Core tables:

affiliates

links

clicks

conversions

subscriptions

renewals

commissions

payouts

Recurring commission logic becomes:

invoice.paid
        ↓
find subscription
        ↓
find original referral
        ↓
apply commission schedule
        ↓
create commission
        ↓
queue payout

This scales well and gives complete control.

Commission models worth supporting

Rather than hardcoding one approach, support multiple rules:

• 30% forever
• 30% for first 12 months
• fixed $50 + 10% recurring
• declining percentages (30 → 20 → 10)
• revenue share after refunds
• minimum payout thresholds
• commission reversals
• tiered partner levels
• coupon attribution
• first-touch vs. last-touch attribution

My shortlist

If your priorities are:

• Most customizable: build your own service around Stripe/Paddle webhooks.
• Best self-hosted commercial: Post Affiliate Pro.
• Best for WordPress: AffiliateWP.
• Best open-source foundation: FOSSBilling plus a custom commission module.

If you're building a modern SaaS with recurring billing, it's also common to pair a billing platform (such as Stripe, Paddle, or Chargebee) with a custom affiliate microservice that listens to billing webhooks. That approach keeps the affiliate logic independent of the billing system while making recurring commissions straightforward to calculate and audit.

If you’re technical and want self-hosted affiliate software for recurring commissions (SaaS-style referrals), I’d focus less on “affiliate marketing suites” and more on event-driven referral/partner ledgers. Recurring commissions require good handling of subscriptions, upgrades, downgrades, refunds, churn, attribution windows, and payout states.

The landscape is a bit thin: many mature affiliate platforms are closed SaaS, while open-source/self-hosted options tend to be newer or require some engineering. openpartner.dev

Options worth evaluating

Also consider: build vs. adopt

For a technical team, the core you actually need is usually:

1. Referral identity
   • affiliate ID
   • tracking links
   • coupon codes
   • partner metadata

2. Immutable events
   • signup
   • trial_started
   • subscription_created
   • invoice_paid
   • refund_created
   • subscription_cancelled

3. Commission ledger
   • commission earned
   • pending period
   • approved
   • paid
   • reversed

4. Attribution rules
   • first touch vs last touch
   • cookie duration
   • self-referral blocking
   • account-level ownership

A lot of affiliate software gets the UI right but treats commissions as a calculation instead of a financial ledger. For recurring SaaS commissions, I’d prioritize a system where you can replay events and recompute commissions.

My shortlist by scenario

You run Stripe SaaS

Start with:

1. Numok
2. RefearnApp
3. Refferq

You want maximum control and don’t mind engineering

Start with:

1. OpenPartner
2. Your own event ledger + lightweight affiliate portal

You need a polished business-facing product today

You may find closed-source tools stronger (especially around payout automation, tax forms, fraud detection, and affiliate UX), but you lose self-hosting.

Questions I’d ask before choosing

• Are you using Stripe Billing, Paddle, Lemon Squeezy, Chargebee, or custom billing?
• Do affiliates earn for the life of the customer or a fixed number of months?
• Do you need automated payouts (PayPal/Stripe Connect/Wise), or just payout reports?
• Is this for one SaaS product or a multi-tenant platform where your customers run their own affiliate programs?

The answer changes the recommendation quite a bit.

If you specifically want self-hosted affiliate software that supports recurring commissions (for subscriptions, SaaS, memberships, etc.), the options are surprisingly limited. Most modern affiliate platforms have moved to SaaS, so you'll likely be choosing between mature PHP applications, WordPress plugins, or building on top of an open-source tracking platform.

Here's how I'd break it down.

1. Post Affiliate Pro

Post Affiliate Pro

Probably the most feature-complete self-hosted product still actively maintained.

Pros:

• recurring commissions
• lifetime commissions
• multi-tier affiliates
• coupon attribution
• REST API
• fraud detection
• webhook support
• many payment integrations

Cons:

• proprietary
• licensing cost
• PHP stack

If you're running a subscription business, this is one of the strongest options.

2. iDevAffiliate

iDevAffiliate

Another long-running self-hosted solution.

Pros:

• recurring commissions
• custom commission rules
• MLM/multi-tier options
• API
• PayPal/Stripe integrations
• mature codebase

Cons:

• older UI
• less modern developer experience

Many hosting companies and SaaS vendors still use it.

3. AffiliateWP (WordPress)

AffiliateWP

If your subscriptions already live in WordPress (WooCommerce, Easy Digital Downloads, MemberPress, etc.), AffiliateWP is excellent.

Supports recurring referrals for:

• WooCommerce Subscriptions
• MemberPress
• Restrict Content Pro
• Easy Digital Downloads
• Paid Memberships Pro

Developer-friendly:

• hooks
• filters
• REST API
• custom integrations

4. SliceWP

SliceWP

A lighter alternative to AffiliateWP.

Good if you need:

• recurring commissions
• Stripe subscriptions
• WooCommerce
• memberships

Less enterprise-oriented but pleasant to work with.

If open source is your highest priority

This is where things become difficult.

There really isn't a widely adopted, fully open-source affiliate management platform comparable to modern SaaS products.

People usually combine:

• Matomo
• subscription billing (Stripe/Paddle/Lemon Squeezy)
• a custom affiliate service
• PostgreSQL
• webhooks

Architecture:

Stripe Subscription
        │
Webhook
        │
Affiliate Service
        │
Commission Ledger
        │
Payout Queue
        │
PayPal / Wise / ACH

This is surprisingly straightforward if you're comfortable writing backend services.

Another engineering-friendly approach

Many SaaS companies build their own because recurring commissions are essentially a ledger problem.

Typical schema:

Affiliates
Customers
Subscriptions
Invoices
CommissionRules
CommissionEvents
CommissionBalances
Payouts

Whenever a successful renewal webhook arrives:

Invoice Paid

↓

find affiliate

↓

calculate %

↓

insert commission

↓

mark payable after refund window

Advantages:

• deterministic
• auditable
• versioned commission rules
• easy reversals
• no vendor lock-in

What you probably want in recurring programs

Look for support for:

• recurring commissions
• first-payment-only option
• recurring for N months
• recurring for lifetime
• lifetime customer attribution
• coupon attribution
• self-referrals prevention
• webhook support
• REST API
• payout holds
• refund reversals
• multi-currency
• VAT-aware calculations

If you're comfortable building infrastructure

A modern stack could be:

• Backend: Go, Rust, or Node.js
• PostgreSQL
• Redis
• Stripe webhooks
• Admin UI (React or Vue)
• Click tracking service
• Signed tracking cookies
• Event-sourced commission ledger

That gives you complete flexibility for custom commission models, recurring subscriptions, and integrations without licensing constraints.

Recommendations by priority

• Most mature self-hosted: Post Affiliate Pro
• Best balance of features and simplicity: iDevAffiliate
• Best for WordPress ecosystems: AffiliateWP
• Best lightweight WordPress option: SliceWP
• Most flexible open-source path: Matomo plus a custom commission service driven by your billing webhooks.

If your priority is fully open source rather than just self-hosted, be prepared for more engineering work—the ecosystem lacks a mature, actively maintained open-source affiliate manager with first-class recurring commission support, so many technical teams choose to implement the commission engine themselves on top of their existing billing system.

If you're specifically looking for self-hosted and ideally open-source software that can handle recurring commissions (subscriptions/SaaS), the ecosystem is surprisingly small. Most mature affiliate platforms are SaaS, and recurring billing is where many open-source efforts fall short. openpartner.devrefgrow.com

Here's how I'd break down the current landscape.

1. OpenPartner (my first project to evaluate)

Pros:

• MIT licensed
• Self-hostable
• Designed around SaaS instead of e-commerce
• Native recurring commission concepts
• Modern event-driven attribution
• Built with APIs in mind

Cons:

• Young project
• Smaller community
• Fewer production deployments than legacy products

Best if you want something you'll likely customize.

openpartner.devrefgrow.com

2. RefearnApp

Interesting because it explicitly targets founders wanting ownership of the stack.

Pros:

• AGPL
• Docker deployment
• Stripe integration
• Self-hosting documentation
• Source available on GitHub

Cons:

• Smaller feature set
• Less ecosystem
• Enterprise features still growing

Good fit if you want a simple SaaS affiliate platform without years of legacy baggage.

refearnapp.com

3. Sled

Worth mentioning if you're using Polar or don't mind a newer codebase.

Pros:

• Open source
• Self-hostable
• Subscription renewals
• Refund handling
• Per-affiliate commission overrides
• Fraud prevention

Cons:

• Very new
• Small install base
• Less battle-tested

www.reddit.com

4. Post Affiliate Pro

This is still the "enterprise self-hosted" answer.

Pros:

• Has existed for ~20 years
• Multi-tier commissions
• Lifetime commissions
• Recurring commissions
• Fraud detection
• Large integration ecosystem
• Lots of documentation

Cons:

• Not open source
• Commercial license
• Older PHP architecture
• UI feels dated

If reliability matters more than licensing, it's still hard to beat.

openpartner.devrefgrow.com

If you're comfortable building

Given your technical background, another pattern I'd seriously consider is:

• Attribution service
• Billing webhooks (Stripe/Paddle/Lemon Squeezy/etc.)
• PostgreSQL
• Background worker
• Admin dashboard
• Partner portal

The difficult parts aren't generating referral links—they're:

• click attribution
• Safari ITP/privacy limitations
• subscription lifecycle events
• upgrades/downgrades
• refunds
• commission ledger immutability
• payout reconciliation

Several experienced builders note that these production concerns are where DIY implementations tend to expand significantly beyond the initial prototype. openpartner.devrefgrow.com

Features I'd require

If I were selecting software today, recurring commission support would need:

• immutable commission ledger
• webhook-driven billing sync
• renewal, cancellation, refund events
• lifetime customer attribution
• per-product commission rules
• affiliate-specific overrides
• manual adjustments
• payout batching
• REST API
• webhook callbacks
• Docker deployment
• PostgreSQL (preferably over MySQL)
• SSO/OIDC if used internally

My recommendations

• Most customizable/open: OpenPartner
• Best lightweight OSS: RefearnApp
• Best if using Polar: Sled
• Most proven self-hosted: Post Affiliate Pro

If your organization has engineers and expects to customize attribution logic, I'd lean toward an open-source project with a clean architecture over a legacy commercial platform.

One question that will narrow the recommendations considerably: what billing platform are you using (Stripe, Paddle, Chargebee, Recurly, Lemon Squeezy, Polar, WooCommerce, or something custom)? That's often the deciding factor for recurring-commission support.