Build a Membership Site Using Memberful in 5 Steps

Memberful is a hosted membership platform that handles billing, content gating, and subscriber management. You don't need to build payment infrastructure. Connect it to your existing site—be it WordPress, static, or custom—and it runs the entire subscription layer while you maintain control over your content and branding.

Photo: Samantha Borges on Unsplash

Who this is for: Solo founders offering paid content, newsletters, courses, or community access who wish to avoid crafting a custom billing system. If your setup includes a Ghost blog, WordPress site, or custom static site and you need to gate content behind paid tiers, Memberful provides a direct path to revenue without the hassle of managing Stripe webhooks or database schemas for subscriptions.

Step 1: Create Your Memberful Account and Choose Pricing Tiers

First, head to Memberful and sign up. During onboarding, connect a Stripe account, as Memberful needs Stripe for payment processing. If Stripe isn't set up, you can create an account during setup.

Build your membership plans right away. Memberful supports:

• One-time purchases (lifetime access)
• Recurring monthly or annual subscriptions
• Free trials (optional)
• Multiple tiers with different content access levels

Set pricing thoughtfully. Memberful charges a 4.9% + $0.49 transaction fee on the Standard plan ($0/month) or 2.9% + $0.30 on Pro ($25/month). Memberful's pricing page states that Pro also removes Memberful branding and adds custom fields, which may be important if you're building a professional product.

Concrete example: For a technical newsletter with premium deep-dives, create two plans:

• Free tier: Access to public posts only
• Premium ($10/month or $100/year): All posts, code repositories, live Q&A

Use annual pricing with a discount (e.g., $100/year vs. $120 for 12 months at $10/month). Annual plans improve cash flow and reduce churn.

Step 2: Integrate Memberful With Your Site

Photo: Team Nocoloco on Unsplash

Here's the thing: Memberful is not a CMS. You keep your existing site and layer Memberful on top for gating and billing. Integration depends on your stack.

WordPress

Install the official Memberful WordPress plugin. Once activated:

1. Go to Settings > Memberful in your WordPress admin
2. Enter your Memberful Site ID and Webhook Secret (found in Memberful dashboard under Settings > Webhooks)
3. Configure which posts or pages require membership
4. Use the [memberful_protected_content] shortcode to gate specific sections within posts

The plugin handles OAuth login, content restrictions, and syncing membership status. It's straightforward but requires custom WordPress conditionals using current_user_can() and Memberful's member data for advanced logic.

Ghost

Memberful integrates natively with Ghost via custom integration:

1. Go to Settings > Integrations > Add custom integration in Ghost admin
2. Name it "Memberful" and copy the Content API Key
3. In Memberful dashboard, navigate to Settings > Integrations > Ghost
4. Paste the API key and Ghost URL

Ghost + Memberful uses member tags to control access. Create posts with specific member-only visibility in Ghost, and Memberful syncs member status. This approach is cleaner than WordPress for newsletters but less flexible for custom pages.

Custom or Static Sites

For custom setups (React, Next.js, Hugo, etc.), use Memberful's JavaScript SDK or webhook-based gating.

Client-side gating with the SDK:

<script src="https://yoursite.memberful.com/auth/sign_in"></script>
<script>
  MemberfulEmbed.setup({
    site: "https://yoursite.memberful.com"
  });
</script>

This adds sign-in and sign-up links. For content gating, check member status client-side:

fetch('https://yoursite.memberful.com/api/graphql/member', {
  method: 'POST',
  credentials: 'include',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    query: `{ currentMember { subscriptions { active } } }`
  })
})
.then(res => res.json())
.then(data => {
  if (data.data.currentMember && data.data.currentMember.subscriptions.some(s => s.active)) {
    // Show premium content
  }
});

Server-side gating (recommended for security): Use Memberful webhooks to sync member data to your database. When a member subscribes, Memberful sends a webhook to your endpoint. Store member ID and plan in your DB, then gate routes server-side.

Example Next.js API route:

// pages/api/memberful-webhook.js
import { buffer } from 'micro';
import crypto from 'crypto';

export const config = { api: { bodyParser: false } };

export default async function handler(req, res) {
  const buf = await buffer(req);
  const sig = req.headers['x-memberful-webhook-signature'];
  const secret = process.env.MEMBERFUL_WEBHOOK_SECRET;

  const hmac = crypto.createHmac('sha256', secret);
  hmac.update(buf);
  const digest = hmac.digest('hex');

  if (sig !== digest) return res.status(401).end();

  const event = JSON.parse(buf.toString());
  
  if (event.type === 'member.create' || event.type === 'subscription.create') {
    // Update your DB with member status
  }

  res.status(200).end();
}

This prevents client-side bypass and keeps member data in sync.

Step 3: Design Your Memberful Sign-Up Flow and Emails

Memberful provides a hosted checkout and account dashboard at yoursite.memberful.com. You can't self-host these pages, but customization is possible.

In Settings > Branding, upload your logo, set colors, and add custom CSS. The hosted pages are functional but generic—custom CSS helps, yet customization is limited.

Email templates: Memberful sends transactional emails (welcome, renewal reminders, failed payments). Customize these under Settings > Emails. Default templates are plain. Rewrite them to match your voice.

Example improvement:

Default:

"Your subscription to [Site Name] is now active."

Better:

"You're in. Your first premium post drops Thursday. Check your dashboard for early access to the code repo."

Test the full flow yourself: sign up, cancel, and resubscribe. Memberful's member dashboard is minimal—members can update payment info and cancel, but there's no forum or community features. Need that? Integrate Discord or Circle and sync membership status via webhooks.

Step 4: Configure Content Gating and Access Rules

Gating logic depends on your platform. Memberful’s core model is simple: plans grant access to content. You decide which plans unlock which content.

WordPress Example

Use Memberful's metabox on posts/pages to restrict access by plan. If a post requires a "Premium" plan, non-Premium members see a paywall.

For partial gating (e.g., show intro, hide deep content), use shortcodes:

[memberful_protected_content plan="premium"]
This section is Premium-only.
[/memberful_protected_content]

Custom Sites

Server-side, query member plans and conditionally render:

// Example: Next.js getServerSideProps
export async function getServerSideProps(context) {
  const memberCookie = context.req.cookies._memberful_session;
  // Validate session with Memberful API
  const member = await validateMemberfulSession(memberCookie);

  if (!member || !member.plans.includes('premium')) {
    return { redirect: { destination: '/subscribe', permanent: false } };
  }

  return { props: { content: premiumContent } };
}

This approach works for Next.js, Remix, SvelteKit—any server-rendered framework. Static sites (Hugo, Jekyll) can't gate server-side, so you'll rely on client-side checks or build separate public/private versions.

Tiered access: If you have multiple tiers (Basic, Pro, Enterprise), structure content by tier and check membership level before rendering. Memberful doesn't have built-in role hierarchies; you'll need to implement that logic yourself.

Step 5: Test Payment Flows and Handle Edge Cases

Before launch, test every scenario:

1. New subscription: Sign up, verify email, check content access
2. Failed payment: Use Stripe test card 4000 0000 0000 0341 to trigger failure, confirm Memberful sends dunning emails
3. Cancellation: Cancel subscription, verify access revokes at period end (unless configured otherwise)
4. Refunds: Process a refund in Stripe, check if Memberful webhook revokes access
5. Plan upgrades/downgrades: Switch plans mid-cycle, verify prorated billing

Worth noting: Memberful uses Stripe Billing, so most edge cases mirror Stripe behavior. However, Memberful's webhook delivery isn't instant—expect 1–5 minute delays for access changes.

Common failure: Webhooks don't fire if your endpoint returns non-200 status. Monitor webhook delivery in Settings > Webhooks > Recent deliveries. If webhooks fail, members may subscribe but not get access. Set up retry logic and alerting.

Tax compliance: Memberful doesn't automatically handle VAT or sales tax on the Standard plan. On Pro, you can enable Stripe Tax, which adds compliance for EU VAT and US sales tax. Selling globally might require budgeting for Pro or handling tax manually.

What Nobody Tells You About Memberful

You're locked into Stripe. Memberful only supports Stripe. Want PayPal, crypto, or ACH? Out of luck. Fine for most markets, but limits flexibility.

Exporting members is tough. Memberful has an API but no easy export-to-CSV for members + subscription data. Planning to migrate off Memberful? You'll script your own export via the API. Plan for lock-in.

Not fit for complex products. Need metered billing, usage-based pricing, or enterprise features (SSO, custom contracts)? Memberful is too simple. Designed for content creators, not SaaS. For that complexity, consider Stripe Billing directly or a platform like Chargebee.

Minimal member dashboard. Members can update payment info, view invoices, and cancel. No engagement features, content library UI, or progress tracking. Selling a course or community? Build that layer yourself or use a separate tool (e.g., Circle, Discourse).

Fee structure adds up. On Standard, 4.9% + $0.49 per transaction is steep. A $10/month subscription costs $0.98 per transaction (Stripe's 2.9% + $0.30 = $0.59, Memberful's 2% + $0.19 = $0.39). At 100 subscribers, that’s $1,188/year in fees vs. $708 if built on Stripe directly. Memberful saves dev time but incurs higher costs.

Limited dunning control. Memberful retries failed payments via Stripe's Smart Retries, but custom retry schedules or email sequence configuration isn't possible. High churn from failed payments might require a custom dunning flow.

Frequently Asked Questions

Can I use Memberful without WordPress or Ghost?

Yes. Memberful is platform-agnostic. Integrate it with any site using the JavaScript SDK, REST API, or webhooks. Static sites, custom React apps, and mobile apps can authenticate members via Memberful's OAuth flow and query membership status server-side.

How do I migrate existing subscribers to Memberful?

There's no migration tool. Export subscriber data (emails, plan, billing date) from your current platform, manually create members in Memberful via the dashboard or API, and email subscribers new login credentials or prompt for password reset. If billed elsewhere (e.g., Gumroad, Patreon), cancel those subscriptions to move them to Memberful billing—manual and risky, expect churn.

Does Memberful work with Patreon or ConvertKit?

No direct integration. Memberful replaces those platforms for billing and gating. Moving from Patreon? Migrate subscribers to Memberful and cancel Patreon. ConvertKit can still send emails; sync Memberful member tags via Zapier or webhooks to segment ConvertKit lists by membership tier.

What happens if I cancel my Memberful Pro plan?

Downgrading to Standard means keeping all members and subscriptions, but losing Pro features (custom fields, branding removal, advanced analytics). Subscriptions continue billing normally, unaffected.

Bottom Line

Memberful handles the billing and gating layer so you don’t need to build a subscription system from scratch. While not the cheapest long-term, it facilitates a fast launch. For solo founders keen to monetize content, Memberful enables quick transitions from zero to paid members within hours, not weeks.

Next step: Sign up for Memberful, create a test membership plan, and integrate with your site. Run a $1 test subscription end-to-end. If it works, you're ready to launch. For more insights on tools that can help streamline your workflow, check out our comparison of Notion vs. ClickUp: Which Tool Ships Faster? or learn how to Launch a Web App with Firebase in 7 Steps.

---

Editorial note: This article was produced with AI assistance and reviewed by Javier Valencia. Verified facts are distinguished from editorial opinion throughout the text. External sources linked are independent of NewsTide.