Sezzle

Sezzle is a buy now, pay later (BNPL) payment method that allows buyers to split purchases into installments. Sezzle uses a redirect flow where the buyer sets up the payment plan on the Sezzle hosted page. The buyer enters everything Sezzle needs to underwrite the plan on that page, so no underwriting data passes through Gr4vy.

Setup

Request a Sezzle merchant account from the Sezzle merchant sign-up page.

Credentials

To connect a Sezzle account, obtain the following credentials from the Sezzle dashboard under Settings > API Keys.

Public Key - The public API key for the Sezzle account.
Private Key - The private API key for the Sezzle account.

Sandbox keys are issued separately, from the Sezzle sandbox dashboard.

Webhooks

Sezzle sends the outcome of a payment plan as a webhook, and Gr4vy uses those events to move the transaction to its final state. Without a subscription, transactions stay in buyer_approval_pending until they are synchronized. Sezzle has no dashboard screen for webhook subscriptions, and Gr4vy does not register them for you, so create the subscription yourself against Sezzle’s API. Do this once per Sezzle account, before you take live traffic. Start with the webhook URL for your Sezzle payment service, which is the webhook_url field on the payment service in the Gr4vy dashboard and API. Each payment service has its own URL. Exchange your Sezzle keys for a token, then create the subscription:

TOKEN=$(curl -s -X POST https://gateway.sezzle.com/v2/authentication \
  -H "Content-Type: application/json" \
  -d '{"public_key":"YOUR_PUBLIC_KEY","private_key":"YOUR_PRIVATE_KEY"}' \
  | jq -r .token)

curl -X POST https://gateway.sezzle.com/v2/webhooks \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "YOUR_GR4VY_WEBHOOK_URL",
    "events": ["customer.tokenized", "order.authorized", "order.captured", "order.refunded"]
  }'

Use https://sandbox.gateway.sezzle.com and your sandbox keys when setting this up for a sandbox environment. Those four events are the ones Gr4vy acts on. Subscribing to others has no effect.

Sending a second subscription adds to the existing ones rather than replacing them, and Sezzle delivers every event to each. Check what is already registered with curl -H "Authorization: Bearer $TOKEN" https://gateway.sezzle.com/v2/webhooks before creating another.

Sezzle treats an HTTP 200 as delivery, and retries anything else for up to five days. If every retry fails, Sezzle deletes the subscription and it has to be created again.

Capabilities

Supported countries

Supported currencies

Limitations

Standalone tokenization is not supported. A Sezzle payment method can only be stored as part of a transaction the buyer approves. Set store to true on transaction creation, as described in Subscriptions (MIT).
Multiple captures are not supported. An authorization can be captured once, in full or in part.
Disputes and chargebacks are not reported. Manage Sezzle disputes in the Sezzle dashboard.
Settlement reporting is not supported. Sezzle transactions do not appear in the consolidated settlement report.

Integration

The default integration for Sezzle uses a redirect to a hosted payments page. Start by creating a new transaction with the following required fields.

var transaction = await client.Transactions.CreateAsync(
  transactionCreate: new TransactionCreate()
  {
    Amount = 5000,
    Currency = "USD",
    Country = "US",
    PaymentMethod =
      TransactionCreatePaymentMethod.CreateRedirectPaymentMethodCreate(
        new RedirectPaymentMethodCreate()
        {
          Method = "sezzle",
          Country = "US",
          Currency = "USD",
          RedirectUrl = "https://example.com/callback",
        }
      ),
  }
);

amount := int64(5000)
currency := "USD"
country := "US"
method := components.RedirectPaymentMethodCreateMethodSezzle
redirectUrl := "https://example.com/callback"

redirectPaymentMethodCreate := components.RedirectPaymentMethodCreate{
  Method: method,
  Country: country,
  Currency: currency,
  RedirectURL: redirectUrl,
}
paymentMethod := components.CreateTransactionCreatePaymentMethodRedirectPaymentMethodCreate(redirectPaymentMethodCreate)

transactionCreate := components.TransactionCreate{
  Amount:        amount,
  Currency:      currency,
  Country:       &country,
  PaymentMethod: &paymentMethod,
}

transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)

CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
  .transactionCreate(TransactionCreate.builder()
    .amount(5000L)
    .currency("USD")
    .country("US")
    .paymentMethod(TransactionCreatePaymentMethod.of(RedirectPaymentMethodCreate.builder()
      .method(RedirectPaymentMethodCreateMethod.SEZZLE)
      .country("US")
      .currency("USD")
      .redirectUrl("https://example.com/callback")
      .build()))
    .build())
  .call();

Transaction transaction = transactionResponse.transaction().orElse(null);

$transactionCreate = new TransactionCreate(
  amount: 5000,
  currency: 'USD',
  country: 'US',
  paymentMethod: new RedirectPaymentMethodCreate(
    method: 'sezzle',
    country: 'US',
    currency: 'USD',
    redirectUrl: 'https://example.com/callback'
  )
);
$response = $client->transactions->create($transactionCreate);
$transaction = $response->transaction;

transaction: models.Transaction = client.transactions.create(
  amount=5000,
  currency="USD",
  country="US",
  payment_method={
    "method": "sezzle",
    "country": "US",
    "currency": "USD",
    "redirect_url": "https://example.com/callback",
  }
)

const transaction = await client.transactions.create({
  amount: 5000,
  currency: "USD",
  country: "US",
  paymentMethod: {
    method: "sezzle",
    country: "US",
    currency: "USD",
    redirectUrl: "https://example.com/callback"
  }
})

After the transaction is created, the API response includes a payment_method.approval_url and the status is set to buyer_approval_pending. The approval URL expires after 30 minutes.

{
  "type": "transaction",
  "id": "ea1efdd0-20f9-44d9-9b0b-0a3d71e9b625",
  "payment_method": {
    "type": "payment-method",
    "approval_url": "https://cdn.gr4vy.com/connectors/..."
  },
  "method": "sezzle"
}

Open the approval_url in a popup so the buyer can set up their payment plan with Sezzle. After the buyer approves, they are redirected to the redirect_url you provided when creating the transaction. Do not rely solely on the redirect — either poll the transaction or (recommended) rely on webhooks to detect the final status, for example authorization_succeeded or capture_succeeded.

Cart items

Cart items are optional for Sezzle. When you send them, Gr4vy forwards the line items and any discounts to Sezzle, and Sezzle displays them on the plan setup page. Cart items do not have to add up to the transaction amount.

Subscriptions (MIT)

Sezzle supports storing the buyer’s payment method during the first (customer-present) payment and charging future renewals as merchant-initiated transactions (MIT) using the saved payment method, with no redirect.

Storing a payment method relies on a webhook from Sezzle. Make sure the webhook subscription is in place for your Sezzle account before using store: true, as described in Webhooks.

Buyer approval for reuse

Sezzle asks the buyer to approve reuse on its own hosted page, separately from any prompt in your checkout. Sezzle requires this for its own records, so it can’t be pre-selected or collected on your behalf. Setting store to true is what makes Sezzle show the approval. By default the buyer can finish the purchase without granting it. The payment still succeeds, but no reusable payment method is created, so a checkout that offers the buyer the choice can leave you with a stored payment method you can’t charge again. To close that gap, ask Sezzle to make the approval mandatory for your merchant account. The buyer then can’t complete the purchase without granting reuse, and the requirement applies only to transactions where you set store to true. Sezzle is working on a way to set this per transaction instead, which will remove the account-level step. Either way, treat a stored Sezzle payment method as usable only once it reports a status of succeeded. Don’t assume it from a successful payment.

First payment

Set store to true to save the Sezzle payment method for the buyer. The buyer approves both the payment and the stored payment method on the Sezzle hosted page.

var transaction = await client.Transactions.CreateAsync(
  transactionCreate: new TransactionCreate()
  {
    Amount = 5000,
    Currency = "USD",
    Country = "US",
    PaymentMethod =
      TransactionCreatePaymentMethod.CreateRedirectPaymentMethodCreate(
        new RedirectPaymentMethodCreate()
        {
          Method = "sezzle",
          Country = "US",
          Currency = "USD",
          RedirectUrl = "https://example.com/callback",
        }
      ),
    Store = true,
    PaymentSource = "recurring",
  }
);

amount := int64(5000)
currency := "USD"
country := "US"
method := components.RedirectPaymentMethodCreateMethodSezzle
redirectUrl := "https://example.com/callback"
store := true

redirectPaymentMethodCreate := components.RedirectPaymentMethodCreate{
  Method: method,
  Country: country,
  Currency: currency,
  RedirectURL: redirectUrl,
}
paymentMethod := components.CreateTransactionCreatePaymentMethodRedirectPaymentMethodCreate(redirectPaymentMethodCreate)

transactionCreate := components.TransactionCreate{
  Amount:        amount,
  Currency:      currency,
  Country:       &country,
  PaymentMethod: &paymentMethod,
  Store:         &store,
  PaymentSource: gr4vy.Pointer(components.TransactionPaymentSourceRecurring),
}

transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)

CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
  .transactionCreate(TransactionCreate.builder()
    .amount(5000L)
    .currency("USD")
    .country("US")
    .paymentMethod(TransactionCreatePaymentMethod.of(RedirectPaymentMethodCreate.builder()
      .method(RedirectPaymentMethodCreateMethod.SEZZLE)
      .country("US")
      .currency("USD")
      .redirectUrl("https://example.com/callback")
      .build()))
    .store(true)
    .paymentSource(TransactionPaymentSource.RECURRING)
    .build())
  .call();

Transaction transaction = transactionResponse.transaction().orElse(null);

$transactionCreate = new TransactionCreate(
  amount: 5000,
  currency: 'USD',
  country: 'US',
  paymentMethod: new RedirectPaymentMethodCreate(
    method: 'sezzle',
    country: 'US',
    currency: 'USD',
    redirectUrl: 'https://example.com/callback'
  ),
  store: true,
  paymentSource: 'recurring'
);
$response = $client->transactions->create($transactionCreate);
$transaction = $response->transaction;

transaction: models.Transaction = client.transactions.create(
  amount=5000,
  currency="USD",
  country="US",
  payment_method={
    "method": "sezzle",
    "country": "US",
    "currency": "USD",
    "redirect_url": "https://example.com/callback",
  },
  store=True,
  payment_source="recurring"
)

const transaction = await client.transactions.create({
  amount: 5000,
  currency: "USD",
  country: "US",
  paymentMethod: {
    method: "sezzle",
    country: "US",
    currency: "USD",
    redirectUrl: "https://example.com/callback"
  },
  store: true,
  paymentSource: "recurring"
})

Subsequent payment

After the payment method is saved, use the payment method ID to charge future renewals.

Set payment_method.method to id and pass the saved payment method ID.
Set payment_source to recurring.
Set merchant_initiated and is_subsequent_payment to true.

var transaction = await client.Transactions.CreateAsync(
  transactionCreate: new TransactionCreate()
  {
    Amount = 5000,
    Currency = "USD",
    Country = "US",
    PaymentMethod = TransactionCreatePaymentMethod.CreateTokenPaymentMethodCreate(
      new TokenPaymentMethodCreate()
      {
        Id = "c2495b14-ca95-4199-87c3-27cbfefcbe9e",
      }
    ),
    PaymentSource = "recurring",
    MerchantInitiated = true,
    IsSubsequentPayment = true,
  }
);

amount := int64(5000)
currency := "USD"
country := "US"
merchantInitiated := true
isSubsequentPayment := true

tokenPaymentMethodCreate := components.TokenPaymentMethodCreate{
  ID: "c2495b14-ca95-4199-87c3-27cbfefcbe9e",
}
paymentMethod := components.CreateTransactionCreatePaymentMethodTokenPaymentMethodCreate(tokenPaymentMethodCreate)

transactionCreate := components.TransactionCreate{
  Amount:              amount,
  Currency:            currency,
  Country:             &country,
  PaymentMethod:       &paymentMethod,
  PaymentSource:       gr4vy.Pointer(components.TransactionPaymentSourceRecurring),
  MerchantInitiated:   &merchantInitiated,
  IsSubsequentPayment: &isSubsequentPayment,
}

transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil, nil)

CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
  .transactionCreate(TransactionCreate.builder()
    .amount(5000L)
    .currency("USD")
    .country("US")
    .paymentMethod(TransactionCreatePaymentMethod.of(TokenPaymentMethodCreate.builder()
      .id("c2495b14-ca95-4199-87c3-27cbfefcbe9e")
      .build()))
    .paymentSource(TransactionPaymentSource.RECURRING)
    .merchantInitiated(true)
    .isSubsequentPayment(true)
    .build())
  .call();

Transaction transaction = transactionResponse.transaction().orElse(null);

$transactionCreate = new TransactionCreate(
  amount: 5000,
  currency: 'USD',
  country: 'US',
  paymentMethod: new TokenPaymentMethodCreate(
    id: 'c2495b14-ca95-4199-87c3-27cbfefcbe9e'
  ),
  paymentSource: 'recurring',
  merchantInitiated: true,
  isSubsequentPayment: true
);
$response = $client->transactions->create($transactionCreate);
$transaction = $response->transaction;

transaction: models.Transaction = client.transactions.create(
  amount=5000,
  currency="USD",
  country="US",
  payment_method=models.TokenPaymentMethodCreate(
    id="c2495b14-ca95-4199-87c3-27cbfefcbe9e"
  ),
  payment_source="recurring",
  merchant_initiated=True,
  is_subsequent_payment=True
)

const transaction = await client.transactions.create({
  amount: 5000,
  currency: "USD",
  country: "US",
  paymentMethod: {
    method: "id",
    id: "c2495b14-ca95-4199-87c3-27cbfefcbe9e"
  },
  paymentSource: "recurring",
  merchantInitiated: true,
  isSubsequentPayment: true
})

Subsequent payments are charged against the stored payment method without a redirect, so the transaction reaches authorization_succeeded or capture_succeeded in the create response.

On-site messaging

Sezzle offers an On-Site Messaging Widget that displays the installment breakdown for an item on your product and cart pages, before the buyer reaches checkout. The widget is a script you add to your own site, configured with the merchant ID from your Sezzle dashboard. It is independent of the Gr4vy integration, and Gr4vy does not host or configure it.

A product page showing a price of 100, with the Sezzle widget below it offering 5 payments of 20. — Sezzle On-Site Messaging Widget on a product page

For installation and configuration options, see the Sezzle On-Site Messaging Widget documentation.

Testing

Sezzle issues sandbox API keys separately from live keys. Generate them in the Sezzle sandbox dashboard, and configure them on a Gr4vy connection in your sandbox environment.

Setting up a plan as a buyer

The Sezzle hosted page asks the buyer to sign in or create a Sezzle account. That account is separate from your Sezzle merchant account, and in sandbox every detail except the email address can be fictional.

Order total - Keep the transaction between 2000 and 250000 (20.00 and 2,500.00 USD). Sezzle’s sandbox rejects totals outside that range.
Phone number - Any correctly formatted number. Sezzle validates the format but doesn’t send a message in sandbox.
One-time password (OTP) - Always 123123, for both phone and email.
Social security number (SSN) - Use 123-54-6789 to test an accepted plan, or 987-65-4321 to test a rejected one.

Test cards

Sezzle accepts the following card numbers in sandbox, with any future expiry date and any 3-digit security code. American Express uses a 4-digit security code. Prefer the Visa or Mastercard number when setting a default card, as described in Testing a stored payment method.

Scheme	Number
American Express	`378282246310005`
Discover	`6011111111111117`
Mastercard	`5555555555554444`
Visa	`4242424242424242`

Test bank accounts

When the buyer pays from a bank account instead of a card, use the following details.

Currency	Details
CAD	Institution `000`, transit `11000`, account `000123456789`
USD	Routing `110000000`, account `000123456789`

Testing a stored payment method

Sezzle runs its own risk and approval checks on every order, including orders charged against a stored payment method, and declines one where the buyer has no default card on file. A sandbox shopper account can reach that state even after completing the tokenization flow, which leaves you with a stored payment method that looks valid but declines on every charge. Before testing a merchant-initiated transaction, sign in to the shopper account at the Sezzle customer dashboard and set a default card, using the Visa or Mastercard number above. For further test values, see the Sezzle test cards.

Common issues

A transaction stays in buyer_approval_pending after the buyer approves

Sezzle reports the outcome of a payment plan by webhook, and Gr4vy needs that event to move the transaction to its final state. If no webhook subscription is registered against your Sezzle account, the buyer completes the plan on Sezzle’s page and returns to your site, but the transaction never leaves buyer_approval_pending.Check the order in the Sezzle dashboard. If it shows as authorized there but not in Gr4vy, the subscription is missing. See Webhooks.Synchronizing the transaction also resolves it, but that is a recovery step rather than a substitute for the subscription.

A charge against a stored payment method is declined

Sezzle runs its full risk, approval and good-standing checks on every order, including orders charged against a stored payment method. One of those checks is that the buyer has a default card on file with Sezzle, and an order from a buyer without one is declined.The stored payment method is still valid, so nothing about it signals the problem. The transaction declines and the order shows as not approved on Sezzle’s side.Only the buyer can resolve this, by setting a default card in their Sezzle account. When testing, set one on the sandbox shopper account as described in Testing a stored payment method.

A stored payment method never becomes usable

Sezzle asks the buyer to approve reuse on its own page, and the buyer can decline it while still completing the purchase. When that happens the payment succeeds but no reusable payment method is created, so the payment method stays unusable and later charges against it fail.Ask Sezzle to make the approval mandatory for your merchant account, as described in Buyer approval for reuse. Until then, check that the payment method reports a status of succeeded before charging it again.

Sezzle rejects the order amount

Sezzle applies its own minimum and maximum order amounts, and rejects a transaction outside that range with a message naming the limit. The limits depend on your account and on the buyer, so a value that works for one buyer can be declined for another.In sandbox, keep the order total between 2000 and 250000 (20.00 and 2,500.00 USD). For live limits, check with Sezzle.

Introduction

Aggregators

Methods

Digital wallets

Anti-fraud

Browse

Setup

Credentials

Webhooks

Capabilities

Supported countries

Supported currencies

Limitations

Integration

Cart items

Subscriptions (MIT)

Buyer approval for reuse

First payment

Subsequent payment

On-site messaging

Testing

Setting up a plan as a buyer

Test cards

Test bank accounts

Testing a stored payment method

Common issues

​Setup

​Credentials

​Webhooks

​Capabilities

​Supported countries

​Supported currencies

​Limitations

​Integration

​Cart items

​Subscriptions (MIT)

​Buyer approval for reuse

​First payment

​Subsequent payment

​On-site messaging

​Testing

​Setting up a plan as a buyer

​Test cards

​Test bank accounts

​Testing a stored payment method

​Common issues

Setup

Credentials

Webhooks

Capabilities

Supported countries

Supported currencies

Limitations

Integration

Cart items

Subscriptions (MIT)

Buyer approval for reuse

First payment

Subsequent payment

On-site messaging

Testing

Setting up a plan as a buyer

Test cards

Test bank accounts

Testing a stored payment method

Common issues