BuddyPress

How to Let People Pay for Community Access With One Click and Get In Instantly

How to take payment and give access in one step: Stripe Checkout, a signed webhook, roles and groups, failed payments, refunds and trials, with BuddyNext Pro and other options compared.

·14 min read
Four-step flow: pay on hosted checkout, confirm with a signed webhook, grant role and group, member is inside and logged in

The fastest reliable way to let people pay for community access and get in immediately is a hosted Stripe Checkout page, a signed webhook that creates the account and assigns the role, and a success page that logs the buyer in only after your server has confirmed the payment. The webhook does the real work. The success page is a convenience, and it has to be safe to run twice, because Stripe’s own guidance is that you cannot rely on the buyer ever reaching it.

We build paid communities for clients on BuddyPress and on BuddyNext, and the same four jobs show up every time: take the money, create the account, grant the right access, and handle the day payment stops working. This guide covers all four, with the Stripe details checked against Stripe’s documentation on 15 November 2026, and compares three routes: our own plugins, other WordPress plugins, and hosted platforms such as Circle, Skool and Whop.

A note on what we sell. BuddyNext Pro, from Wbcom Designs (the team behind this site), is one of the options below. It is the right fit for some sites and the wrong one for others, and we say which. If you only want a ranked list of membership plugins, read our WordPress membership plugins roundup instead. This page is about the flow from payment to access, not about picking a plugin.

How do you let people pay for community access and get in instantly?

Think of it as one chain with four links. The buyer pays on a hosted page. Stripe tells your site the payment worked. Your site creates or finds the user and gives them access. The buyer lands inside, logged in. When any link is slow or breaks, the buyer sees a spinner, a login form they do not have credentials for, or a page that says they are not a member yet.

Step

Who does it

What can go wrong

How to prevent it

1. Checkout

Stripe (hosted page)

Buyer closes the tab after paying

Do not depend on the return page for access

2. Webhook

Your site, called by Stripe

Blocked by a firewall, wrong events, wrong keys, body altered

Test delivery from the Stripe dashboard before launch

3. Account and role

Your site

User already exists, email typo, double processing

Look up by email, make the function safe to run twice

4. Group or space access

Your site

Role granted but group not joined

Do role and group in the same function, log the result

5. Login handoff

Your site, on the success page

Link reused or shared

Verify payment server-side, single use, short lifetime

6. Later: failure, refund, cancel

Stripe and your site

Access stays after refund, or ends too early on a failed card

Handle the events listed further down

Stripe says the same thing about step 2 in its fulfilment guide: webhooks are required for subscriptions and for payment methods that confirm later, such as bank debits, and the return page can only be a bonus. You can read it at docs.stripe.com/checkout/fulfillment.

What happens between the payment and the member getting access?

Step 1: Hosted Checkout

Use Stripe Checkout, either by creating a Checkout Session from your server or by sharing a Payment Link. Both give you card entry, 3D Secure and saved cards without you touching card data. Pass a client_reference_id or metadata with the plan or group you are selling, so the webhook knows what to grant. If the buyer is already logged in, pass their user ID the same way. That is how you avoid creating a second account for someone who already has one.

One correction to a common mix-up, which we also made in an earlier version of this post: after_completion is a Payment Link setting. A Checkout Session uses success_url and cancel_url. Put {CHECKOUT_SESSION_ID} in the success URL and Stripe fills in the real session ID when it redirects.

Step 2: The webhook

When a Checkout Session completes, Stripe sends a checkout.session.completed event to your endpoint. Payment methods that confirm later send checkout.session.async_payment_succeeded when the money actually arrives, so listen for both. Your handler must verify the signature, return a 2xx response quickly, and do the slow work safely. Stripe warns that anything that changes the raw request body, including some frameworks’ JSON parsing, makes signature verification fail.

Stripe retries failed deliveries for up to three days in live mode with exponential backoff, does not guarantee event order, and can send the same event more than once. Those three facts shape how you write the handler. Source: Stripe webhooks documentation.

Step 3: Account, role and group

In WordPress the account is a user row, the role is a capability bundle, and on a BuddyPress site the group is a separate membership record. Treat them as three writes in one function. If you only set a role and forget the group, the member is paid and inside the site but looks at an empty community.

Step 4: Login handoff

WordPress has no built-in magic link, but you do not need a plugin for the first session. On the success page, read the session ID from the URL, ask Stripe for that session from your server, confirm it is paid, confirm it belongs to the user you fulfilled, and call core’s wp_set_auth_cookie(). Then mark the session as used so the link works once. If a session ID leaks, an unmarked link would log a stranger in as your customer, so the single-use check is a security control and not a nicety. Also send the normal “set your password” email, because the first login will not be the last.

Why must the webhook and the success page both be safe to run twice?

Because both will run for most buyers. The success page fires when the buyer returns, and the webhook fires whether or not they do, and either can arrive first. Stripe’s guide says your fulfilment function may be called more than once, possibly at the same time, for the same Checkout Session, and has to handle that. The pattern is one function, keyed by session ID, called from both places, that does nothing the second time.

Below is a sketch of the pattern for a WordPress site. It is a starting point and not a finished plugin: it assumes you have loaded the official Stripe PHP library, and it uses add_option() as a cheap lock, which is fine for a small community and should move to a dedicated table or user meta once you have thousands of sessions. We checked the calls against Stripe’s and WordPress’s documentation on 15 November 2026 and have not shipped it as-is.

add_action( 'rest_api_init', function () {
	register_rest_route( 'community/v1', '/stripe-webhook', array(
		'methods'             => 'POST',
		'callback'            => 'mc_stripe_webhook',
		'permission_callback' => '__return_true', // The Stripe signature is the check.
	) );
} );

function mc_stripe_webhook( WP_REST_Request $request ) {
	try {
		$event = \Stripe\Webhook::constructEvent(
			$request->get_body(),                 // Raw body, untouched.
			$request->get_header( 'stripe-signature' ),
			MC_STRIPE_WEBHOOK_SECRET
		);
	} catch ( \Exception $e ) {
		return new WP_REST_Response( array( 'error' => 'invalid' ), 400 );
	}

	$types = array( 'checkout.session.completed', 'checkout.session.async_payment_succeeded' );
	if ( in_array( $event->type, $types, true ) ) {
		mc_fulfill_checkout( $event->data->object->id );
	}
	return new WP_REST_Response( null, 200 );
}

function mc_fulfill_checkout( $session_id ) {
	// Atomic-enough lock: add_option() fails if the row exists.
	if ( ! add_option( 'mc_done_' . $session_id, time(), '', 'no' ) ) {
		return; // Already fulfilled, or being fulfilled right now.
	}

	$stripe  = new \Stripe\StripeClient( MC_STRIPE_SECRET_KEY );
	$session = $stripe->checkout->sessions->retrieve( $session_id );
	if ( 'unpaid' === $session->payment_status ) {
		delete_option( 'mc_done_' . $session_id ); // Wait for the async event.
		return;
	}

	$email = sanitize_email( $session->customer_details->email );
	$user  = get_user_by( 'email', $email );
	if ( ! $user ) {
		$user_id = wp_insert_user( array(
			'user_login' => $email,
			'user_email' => $email,
			'user_pass'  => wp_generate_password( 24 ),
			'role'       => 'subscriber',
		) );
		if ( is_wp_error( $user_id ) ) {
			delete_option( 'mc_done_' . $session_id ); // Let the retry try again.
			return;
		}
		wp_new_user_notification( $user_id, null, 'user' ); // Set-password email.
		$user = get_user_by( 'id', $user_id );
	}

	$user->add_role( 'paid_member' );
	if ( function_exists( 'groups_join_group' ) && ! empty( $session->metadata->group_id ) ) {
		groups_join_group( (int) $session->metadata->group_id, $user->ID );
	}
}

Checked on 15 November 2026. Three details matter more than the code. The signature check uses the raw body. A failed account creation releases the lock so Stripe’s retry can finish the job. And the function reads the session from Stripe’s API instead of trusting the event payload alone, which is the order Stripe’s guide recommends.

What does BuddyNext Pro do out of the box?

If you would rather configure than code, BuddyNext Pro covers most of the chain above. We read its documentation and changelog on 15 November 2026 (Pro 1.2.9 is the current release in the docs). With a Stripe connection, a member who reaches a paywall pays on Stripe’s hosted checkout and gets in as soon as Stripe confirms. Membership plans can unlock whole Spaces (BuddyNext’s groups) or single pieces of content, and a plan can also be sold by a private link that stays off the pricing page.

Two settings matter for the “pay and get in” case. Paying members only makes the whole community require an active paid plan: visitors see only paid plans, choose one, sign up, pay and land in the community. And on a pricing page a logged-out visitor who picks a plan is taken to registration first and then straight into checkout for that plan, so choosing and signing up feel like one step.

  • Payment gateways: Stripe and PayPal, plus a no-keys Test gateway so you can walk the whole flow before going live.
  • Failed payments and refunds: a failed renewal marks the member past due, and a refund or dispute ends access. A partial refund adjusts the order and leaves access alone.
  • Member self-service: a billing page where members update their card, change plan and download invoices, backed by Stripe’s billing portal.
  • Other billing tools: plans can also be granted from WooCommerce, Paid Memberships Pro, or from Make, Zapier and n8n through an access webhook.

Now the real cons, because they decide whether it fits you:

  • BuddyNext Pro is a paid add-on to free BuddyNext. Payments are a Pro feature, so the free plugin alone will not charge anyone.
  • BuddyNext is its own platform, not a BuddyPress add-on. A site that already runs on BuddyPress with BuddyPress-only plugins would be a migration, not a switch you flip.
  • The Stripe webhook is mandatory for anything after the first purchase. The docs are blunt about it: without the webhook, renewals, cancellations and failed payments never reach your site. BuddyNext has a safety net for the moment of purchase, and nothing for the months after.
  • Stripe’s billing portal has to be activated in your Stripe account before the Update payment method button works.
  • Refunds are issued in Stripe or PayPal, not from inside BuddyNext. The plugin reacts to them.

Details are on buddynext.com. If your community is on BuddyPress and you only need to charge for it, the themes we build those sites with, BuddyX and Reign, do not change the payment flow at all: the theme styles the pages, and a membership plugin does the access work. For the gating side on BuddyPress, see our guide to locking BuddyPress pages and custom post types.

Which other WordPress options give you paid access with BuddyPress?

Plenty of sites already run a membership plugin and only need it connected to the community. This table sticks to what we confirmed on the vendors’ own pages on 15 November 2026. For fuller reviews and ratings, use the membership plugins roundup and our BuddyPress and MemberPress comparison.

Option

How it connects to BuddyPress

Worth knowing

Paid Memberships Pro with its BuddyPress add-on

Adds members to groups, invites them to private groups and assigns member types by membership level; removes them when they lose the level

Distributed from paidmembershipspro.com, not the WordPress.org directory (the directory listing was closed at the author’s request in October 2024)

MemberPress with its BuddyPress Integration add-on

Links the account page to the BuddyPress profile and can add or remove users from groups by subscription status

The add-on’s product page showed its last changelog entry in April 2022, so test it on your versions before relying on it

Paid Member Subscriptions (Cozmoslabs)

Recurring payments, plans and content restriction; free version on WordPress.org (10,000+ active installs, 4.7 average from 270 ratings, updated 2 November 2026)

We did not verify a BuddyPress group integration, so assume a custom bridge is needed

Custom Stripe webhook (the sketch above)

Whatever you write: role, group, member type

Most flexible, and you own every bug in it

BuddyNext Pro

Native: plans unlock Spaces and content

Replaces BuddyPress rather than extending it

If you sell physical or digital goods next to the community, WooCommerce can own the money and the community plugin can own the access. We cover that overlap in BuddyPress and WooCommerce for social commerce.

Is it better to use Circle, Skool or Whop than to build on WordPress?

Sometimes, yes. A hosted platform gives you payment and access in one product with no webhook to maintain. The price is control: your members, your data model and your login live on someone else’s platform. We checked the published prices on 15 November 2026.

Platform

Published pricing

What the pay-then-access flow looks like

Main limit

Circle

Professional $89 a month, Business $199, Scale $419, billed annually; transaction fee 2% on Professional, 1% on Business and Scale, 0.5% on Circle Plus

Native paid access, no setup

Your members live in Circle, so a WordPress site needs its own bridge

Skool

Hobby $9 a month with a 10% transaction fee; Pro $99 a month with 2.9%

Payment and join are one flow

One flat community, little room for tiers; separate from your WordPress site

Whop

We could not confirm a fee table on a page we could load, and third-party reviews disagree on the numbers

Passes grant access to Discord, Telegram and other apps

Read Whop’s own seller fee terms before you compare it to the others

Notice that Skool’s old flat $99 a month and Circle’s older 4 percent fee, which an earlier version of this post quoted, no longer match the published pages. Hosted platforms change prices often, so treat any third-party number, including ours, as dated. Prices are in US dollars and exclude tax.

Pick a hosted platform when speed matters more than ownership, your audience will live entirely inside it, and you are happy with its fee. Pick WordPress when the community is part of a site you already run, when you need your own user database, or when you want the member to see one brand from the first click.

What happens when a member’s payment fails?

A failed renewal is the moment most paid communities decide whether they are a business or a hobby. Stripe’s Smart Retries picks retry times with a model and, for new Stripe accounts, is on by default and set to up to 8 retries within 2 weeks. You can change that to a custom schedule of up to three retries. Cards that fail with a hard decline, such as a lost or stolen card, will not be retried until the member adds a new payment method. Source: Stripe Smart Retries.

After the last attempt, Stripe changes the subscription the way you told it to: cancel it, mark it unpaid, leave it past due, or pause it. That setting is your grace period. Your WordPress site has to read the result and match it. A sensible policy for a community:

  1. Day of the first failure: keep access, send one plain email with a link to update the card.
  2. During the retry window: keep access and mark the member as past due in your admin so you can see who needs help.
  3. When Stripe gives up: end access to paid areas, keep the profile and posts, and send a short win-back message.

The events to handle are invoice.payment_failed, customer.subscription.updated and customer.subscription.deleted. BuddyNext Pro handles the same set and marks the member past due; a member whose renewal fails past the grace period is sent to the plans page from every community page, with a message that says their membership has ended.

How should refunds and cancellations affect access?

Decide the rule before the first refund request, then make the code follow it.

  • Full refund: end access at once. Listen for charge.refunded.
  • Partial refund: usually a goodwill gesture, so keep access. BuddyNext Pro treats it that way: a partial refund adjusts the order and leaves access, and a full refund ends it.
  • Chargeback: end access when the dispute opens (charge.dispute.created) and deal with the evidence separately.
  • Cancellation: keep access until the end of the period the member paid for. Stripe reports such a subscription as still active with a cancel-at-period-end flag, so read that flag and not the status alone.

For self-service, Stripe’s customer portal lets customers update billing details and payment methods, switch plans, pause and resume, cancel immediately or at period end, and download invoices. One limit matters for trials: if a subscription uses trial offers, customers can cancel in the portal but cannot update the plan there. Source: Stripe customer portal docs.

Offer a pause before a cancel if your community has seasonal members, and read the pause docs at Stripe pause subscriptions for what resumes automatically. Our broader view on pricing and member-friendly models is in community monetization models in 2026.

Should you offer a free trial on a paid community?

A trial changes who walks in. With a card required up front, fewer people start, and the ones who do have already decided to try you. With no card, more people start and more drift away unconverted. Neither wins in general, so match it to how fast a new member reaches a first useful moment. A community where value shows up in the first week suits no-card trials. One with a slow onboarding suits card-required.

In Stripe Checkout the trial length belongs under subscription_data, not at the top level:

# Card-required 7-day trial
-d mode=subscription
-d "subscription_data[trial_period_days]=7"

# No card up front; cancel if none is added by the end
-d mode=subscription
-d "subscription_data[trial_period_days]=7"
-d "subscription_data[trial_settings][end_behavior][missing_payment_method]=cancel"
-d payment_method_collection=if_required

Checked on 15 November 2026 against Stripe free trials for Checkout. By default Checkout collects a payment method for use after the trial. if_required skips that, and missing_payment_method decides whether the subscription cancels or pauses if the member never adds one. In BuddyNext Pro, a plan that advertises a trial starts it at the payment provider, and a gateway that cannot start one declines the sale, so nobody is charged on day one by mistake.

Which role, group or member type should a paid member get?

Use the smallest tool that does the job. A WordPress role is right when access is site-wide, such as a paid_member role that unlocks pages. A BuddyPress group is right when access is to one community area. A member type is a label, good for directory filters and badges, and is not an access control on its own. Tiered communities usually need all three, with the role as the lock and the others as the experience.

On BuddyPress, BuddyPress 12.0 changed profile URLs, so any welcome email that links to the member’s profile should use bp_members_get_user_url(), since bp_core_get_user_domain() is deprecated. The current BuddyPress release is 14.5.4, from 23 October 2026. Revoking is the other half: when access ends, remove the role and the group membership, but keep the profile and content, so the member can return without losing their history.

Common mistakes people report

These come from vendor troubleshooting pages, support threads and Stripe’s own documentation, all read on 15 November 2026. We paraphrased them.

  • Granting access only from the success page. A buyer can pay and lose their connection or close the tab before the page loads. Stripe says you cannot rely on the landing page alone, and Ultimate Member’s troubleshooting guide lists a user who left Checkout early as a cause of a paid-but-not-activated account. See Stripe and Ultimate Member docs.
  • A firewall or security plugin blocks the webhook. Paid Memberships Pro lists a blocking plugin as one of three main causes of missing events in an article updated in June 2026, and a Simple Membership user reported in March 2025 that new Stripe subscriptions stopped upgrading accounts until a security plugin was disabled. See PMPro and Simple Membership forum.
  • Wrong events or the wrong keys. A webhook that is missing event types, or that was created with test keys while the site runs on live keys, receives nothing useful. Both PMPro and Ultimate Member list these. Open the webhook in Stripe and compare the event list with your plugin’s documented list.
  • Signature verification fails. Stripe needs the raw request body, and any framework or plugin that parses and re-encodes JSON first breaks the signature. See Stripe webhooks.
  • Processing the same event twice. Stripe can deliver an event more than once, and does not promise ordering. Log processed event or session IDs, and do not grant access, send a welcome email or record revenue a second time.
  • Nothing links the payment to the user. Ultimate Member lists missing client_reference_id or email values as a cause. Pass an identifier at checkout so the webhook can find the right account.

What should you check before you launch?

  1. Run one live-mode payment of the smallest amount yourself, then refund it, and watch both events arrive.
  2. In Stripe, open the webhook and confirm the endpoint URL, the event list and the signing secret all match the site.
  3. Open the webhook URL in a browser and check your firewall does not block it.
  4. Pay twice with the same email and confirm you get one account, one role and one group membership.
  5. Close the tab right after paying, then check the member still has access.
  6. Fail a renewal with a Stripe test card and confirm the past-due state, the email and the final lock.
  7. Issue a full and a partial refund and confirm access follows your rule.
  8. Check the welcome email on a phone, with a profile link that works.

Which approach fits which situation?

Your situation

Our suggestion

Why

New community, no existing members, want it running soon

BuddyNext Pro, or a hosted platform if you do not need your own site

Plans, gating and billing screens are built in; hosted is quicker still but less yours

Existing BuddyPress site, already using a membership plugin

Keep it and connect it: PMPro or MemberPress add-on, tested on your versions

No migration, and the add-ons do group and member type work

Existing BuddyPress site, need something custom

Custom webhook like the sketch above

Full control, but plan for tests and ongoing upkeep

Audience lives on Discord or Telegram

Whop or similar

Access delivery to those apps is its job

One flat community with courses, no WordPress needed

Skool or Circle

One product, one bill, fees as published

Our honest limit: we have not run every option above under load on the same site, so the table reflects documentation and vendor pages as of 15 November 2026 plus our client work. Test on a staging copy before you take real money.

Frequently asked questions

Can a member get in before the webhook arrives?

Yes, if your success page checks the session directly with Stripe, confirms it is paid, and logs the buyer in. BuddyNext Pro does a version of this at the moment of purchase. It is a safety net, and the webhook still has to be set up.

Do I still need email verification?

A paid card payment is strong evidence of a real person, so many sites skip the extra verification step. The risk is a typo in the email, which sends the password link to a stranger. Show the email back on the checkout page, or use the email Stripe collected and send a set-password message.

Is one time or recurring better for community access?

Recurring fits ongoing value such as new content and live events. One time fits a cohort or lifetime offer and removes failed-payment handling, but it also removes your steady income. Offer a monthly and an annual option on the same plan if you can.

How fast should access be granted?

As soon as Stripe confirms payment. Any delay after that is yours: slow code, a slow hosting plan, or a page cache serving the old state. Measure the time between the payment and the member’s first action rather than guessing.

What if the member pays with a different email than their account?

Match on the user ID you passed to Checkout first, then on the email. A purchase should belong to the logged-in member who bought it, not to whatever email was typed at checkout. Show them a clear way to merge accounts if you let guests buy.

The short version: make the webhook the source of truth, make the fulfilment function safe to run twice, decide your rules for failure and refunds before they happen, and test the awkward cases on purpose. For more on turning a community into a business, read our monetization guide next.

Part of the Wbcom Designs family

The all-in-one WordPress community stack

Also ours: wbcomdesigns.comvapvarun.combrndle.com