Enroll Connected Accounts

To enroll a connected account on your platform, create an Account object for them under your platform account. That account can then accept direct charges, receive transfers, and use Whop payout flows.

Example

Create an account for the connected account:

import { WhopClient } from "@whop/sdk";

const client = new WhopClient({
	token: "Account API Key",
});

const account = await client.accounts.create({
	email: "merchant@example.com",
	title: "Acme Merchant Store",
	metadata: {
		external_id: "user_12345",
		seller_tier: "gold",
	},
});

console.log(account.id);

from whop_sdk import Whop

client = Whop(
    token="Account API Key",
)

account = client.accounts.create(
    email="merchant@example.com",
    title="Acme Merchant Store",
    metadata={
        "external_id": "user_12345",
        "seller_tier": "gold",
    },
)

print(account.id)

use whop_sdk::prelude::*;

let config = ClientConfig {
    token: Some("Account API Key".to_string()),
    ..Default::default()
};
let client = Whop::new(config).expect("Failed to build client");

let account = client
    .accounts
    .create(
        &CreateAccountsRequest {
            email: Some("merchant@example.com".to_string()),
            title: "Acme Merchant Store".to_string(),
            metadata: Some(HashMap::from([
                ("external_id".to_string(), json!("user_12345")),
                ("seller_tier".to_string(), json!("gold")),
            ])),
            ..Default::default()
        },
        None,
    )
    .await?;

println!("{}", account.id);

import (
    "context"
    "fmt"
    "log"

    whopsdk "github.com/whopio/whopsdk-go/v2"
    "github.com/whopio/whopsdk-go/v2/client"
    "github.com/whopio/whopsdk-go/v2/option"
)

client := client.NewWhop(option.WithToken("Account API Key"))

account, err := client.Accounts.Create(context.TODO(), &whopsdk.CreateAccountsRequest{
    Email: whopsdk.String("merchant@example.com"),
    Title: "Acme Merchant Store",
    Metadata: map[string]any{
        "external_id": "user_12345",
        "seller_tier":      "gold",
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(account.ID)

In this example:

email is the connected account’s email address. Whop uses it to identify the connected account and send important notifications.
The Account API key determines which platform account owns the connected account.
title is the required display name for the connected account.
metadata contains custom key-value pairs:
- external_id: Your platform’s identifier for this connected account. Whop uses it to tell apart connected accounts that share an email address.
- seller_tier: A classification or tier level for the connected account (e.g., “bronze,” “silver,” or “gold”)
The response includes an account.id that you can use to reference this connected account in future API calls

The email address should belong to the connected account (business or individual) who will be managing the account. This person will receive account setup and payment notifications.

Reusing an email address

Several connected accounts can share one email address, as long as each one has a distinct metadata.external_id. Creating an account is idempotent on the email and external_id pair:

New external_id: Whop creates a new connected account, even when the email is already in use.
Same email and external_id: Whop returns the existing connected account instead of creating a duplicate, so retries are safe.
No external_id: Whop returns the existing connected account for that email that has no external_id, if there is one.

Accounts that share an email are managed by the same Whop user, the person who receives that inbox.

Finish onboarding

If the recipient doesn’t already have a Whop account, send them an account onboarding link after you create the account. They complete Know Your Customer (KYC) verification through that link, and then the account can receive transfers and other payout flows.

const accountLink = await client.accountLinks.create({
	company_id: account.id,
	refresh_url: "https://yourapp.com/onboarding/refresh",
	return_url: "https://yourapp.com/onboarding/complete",
	use_case: "account_onboarding",
});

console.log(accountLink.url);

account_link = client.account_links.create(
    company_id=account.id,
    refresh_url="https://yourapp.com/onboarding/refresh",
    return_url="https://yourapp.com/onboarding/complete",
    use_case="account_onboarding",
)

print(account_link.url)

let account_link = client
    .account_links
    .create(
        &CreateAccountLinksRequest {
            company_id: "biz_xxxxxxxxxxxxx".to_string(),
            refresh_url: "https://yourapp.com/onboarding/refresh".to_string(),
            return_url: "https://yourapp.com/onboarding/complete".to_string(),
            use_case: AccountLinkUseCases::AccountOnboarding,
        },
        None,
    )
    .await?;

println!("{}", account_link.url);

accountLink, err := client.AccountLinks.Create(context.TODO(), &whopsdk.CreateAccountLinksRequest{
    CompanyID:  "biz_xxxxxxxxxxxxx",
    RefreshURL: "https://yourapp.com/onboarding/refresh",
    ReturnURL:  "https://yourapp.com/onboarding/complete",
    UseCase:    whopsdk.AccountLinkUseCasesAccountOnboarding,
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(accountLink.URL)

After the recipient completes onboarding, you can:

create checkout flows for them with application fees.
transfer funds to their account balance.
let them withdraw funds with the payout portal.

Getting started

Before you can enroll connected accounts, you need to set up your platform account:

Sign up for a platform account: Create an account at whop.com/dashboard
Generate an Account API key: Go to your developer settings page and generate an Account API key
Use the API key for authentication: This API key is how you authenticate with the Current API and control your connected accounts

The Account API key provides the necessary permissions to create and manage connected accounts under your platform account.

Custom metadata

You can attach custom metadata to accounts when creating them. Metadata lets you store additional information about each connected account as key-value pairs. This is useful for:

Storing your internal user or merchant identifiers
Tracking connected account tiers or classifications
Linking to your platform’s database records

Whop stores metadata on the Account object. You can retrieve it later for reporting, filtering, or integration purposes.

API reference

Create Account API

See the full API reference for creating accounts and all available parameters

Next steps

After creating an Account for a connected account:

Collect and split payments

Choose between direct charges and transfers

Render payout portal

Let connected accounts withdraw their funds

​Example

​Reusing an email address

​Finish onboarding

​Getting started

​Custom metadata

​API reference

Create Account API

​Next steps

Collect and split payments

Render payout portal

Example

Reusing an email address

Finish onboarding

Getting started

Custom metadata

API reference

Next steps