How SideShift implement embedded payouts using Whop

UGC creator platform, SideShift, implements embedded payouts using Whop. Here's how.

Sideshift was built to make scaling UGC easy. One platform connects 850k+ creators with brands like Picsart, Replit, Kalshi, Paramount, and more. It’s genius, but it only works at scale when creator payouts are seamless and secure. 

That volume of activity requires serious payments infrastructure.

Here’s why SideShift chose Whop to power UGC creator payouts. 

A platform built for running UGC at scale

Running UGC campaigns for just a few brands? Sure, that's easy.

Managing campaigns between thousands of brands, and hundreds of thousands of creators? Not so much.

SideShift brings creator sourcing, campaign management, tracking, and payouts into one clean system. More than 1,000 brands use SideShift to find and hire creators, with millions of dollars being paid out per week.

As well as giving brands a way to scale UGC without managing everything manually; SideShift helps creators access better brand campaigns and manage earnings in a single place.

Growing faster than old infrastructure could keep up with

SideShift was scaling the creator side of the platform super fast. The next challenge was payouts.

Because handling payouts across thousands of creators, different withdrawal methods, compliance requirements, and onboarding flows? That requires the right tech. 

The platform needed a solution capable of handling large volumes of creator payouts, onboarding and identity verification, multiple payout methods, and withdrawals. SideShift's scale means that payouts affect more than finance ops, they shape the creator experience.

Before using Whop, SideShift relied on another provider to manage pay-ins and payouts, but the platform kept experiencing issues:

"For pay-ins it was fine, but for payouts there was a lot of friction on both KYC and the withdrawal process," says Drew Levin, SideShift's co-founder and CTO.

"Whop also offers a variety of different payout options whereas our last partner only offered bank withdrawals."

It's worth noting creators now expect near-instant access to earnings. According to PYMNTS, 54% of gig workers want access to funds the same day they’re issued, yet only 36% of platforms consistently offer instant payouts.

That's why pretty much all creator-based platforms are moving toward payouts becoming part of the product experience itself, because it gives all parties more control, flexibility, and security. 

"Now our creators can start earning with a lot less friction, which makes the platform a lot easier to use and the experience a lot better."

What it actually takes to move millions of dollars a week to 850k creators

On SideShift, payouts are tied directly to campaign activity. As creators publish content and complete deliverables, payout progress updates inside the platform. That means brands can see what’s been completed, approved, and pending, while creators can track earnings and withdrawal status in real time. 

The platform also supports more than 50 payout structures, including:

• Fixed retainers
• Pay-per-post campaigns
• Performance-based payouts tied to views
• Hybrid compensation models

Some creators earn flat campaign fees. Others earn bonuses based on engagement and performance. That sort of payout flexibility is a big part of what makes the platform useful for brands. 

But supporting all those different campaign models? That makes payouts a lot more complicated behind the scenes. That’s why SideShift integrated Whop’s payout infrastructure directly into the product.

Creators can complete identity verification, connect payout destinations, manage withdrawals, and track earnings without leaving the platform.

Platforms can use Whop to Use pay out in over 241+ territories with every method, from bank deposits to Crypto, Venmo, CashApp, and more.

How SideShift implement embedded payouts with Whop

SideShift already managed creator onboarding, campaigns, approvals, and earnings inside the product.

Rather than redirecting creators into a separate payout experience, the team used Whop’s embedded payouts tooling to keep identity verification, payout setup, and withdrawals inside the existing workflow.

Whop supports both hosted and embedded payout experiences. For platforms that want full control over the user experience, embedded components let payouts render directly inside the application.

Follow the steps below to set up the server-side token generation and client-side components.

Set up your server

First, install the Whop SDK and connect it to your API key.

Then create an endpoint on your server that generates a temporary access token for each connected account: this token is what gives them access to the payout portal.

When a user requests access, your endpoint should check who they are, accept their company ID, and send back that temporary token.

import type { NextRequest } from "next/server";

import Whop from "@whop/sdk";

const whop = new Whop({
	apiKey: process.env.WHOP_API_KEY,
});

export async function GET(request: NextRequest) {
	const companyId = request.nextUrl.searchParams.get("companyId");

	if (!companyId) {
		return new Response(null, { status: 400 });
	}

	const tokenResponse = await whop.accessTokens.create({
		company_id: companyId,
	});

	return Response.json({ token: tokenResponse.token });
}

Build a payouts portal on the client

On the client side, install the Whop embedded components packages for React.

Wrap your payout components with Elements and PayoutsSession : the session handles authentication using the token your server generates.

You'll need to pass in three things: a function that fetches the access token from your server, the connected account's company ID, and a redirect URL for after identity verification is complete.

From there, you can add three components to your portal. One displays the account's current balance, how much is available to withdraw. Another adds a withdrawal button that opens a modal where users enter an amount and confirm. The third shows a list of past withdrawals and their current status, so creators can track where their money is.

import {
	BalanceElement,
	Elements,
	PayoutsSession,
	WithdrawButtonElement,
	WithdrawalsElement,
} from "@whop/embedded-components-react-js";
import { loadWhopElements } from "@whop/embedded-components-vanilla-js";

const elements = loadWhopElements();

export function PayoutPortal({ companyId }: { companyId: string }) {
	return (
		<Elements elements={elements}>
			<PayoutsSession
				token={() =>
					fetch(`/api/token?companyId=${companyId}`)
						.then((res) => res.json())
						.then((data) => data.token)
				}
				companyId={companyId}
				redirectUrl="https://yourapp.com/verification-complete"
			>
				<BalanceElement fallback={<div>Loading...</div>} />
				<WithdrawButtonElement fallback={<div>Loading...</div>} />
				<WithdrawalsElement fallback={<div>Loading...</div>} />
			</PayoutsSession>
		</Elements>
	);
}

After following these steps you will have successfully embedded the payout components in your application.

Whop: where the internet does business

SideShift didn’t need just another payout provider. It needed payouts to work the same way the rest of the platform worked: fast, embedded, and invisible.

Campaigns, approvals, earnings, withdrawals; all inside one system. Whop makes that possible.

Instead of building onboarding flows, identity verification, payout rails, and withdrawals from scratch, SideShift just plugged payouts directly into their existing product experience.

Less operational drag, more flexibility for creators. 

Creator platforms need to do more than just connect people. They need to handle everything that happens after the work gets done, too. 

Want to build payouts directly into your own platform? Start here.