Create a cardless trial

Cardless trials let customers try your app before they commit to paying. Unlike card-required trials, they don't require a credit card to sign up, making it easier for customers to try your product.

Access to cardless trials is limited to users who are part of our developer preview program. If you're interested in joining the program, read the testing overview guide and join the waitlist. We'll reach out when space is available if you meet the program requirements.

View early access overview and join

What are we building?

In this tutorial, we'll create a subscription that doesn't require a payment method when signing up. We'll then add a payment method to the subscription, so that it's ready to transition to paying.

We'll learn how to:

• Create a price for an item that has a trial period that doesn't require a payment method
• Create a transaction using the API for a customer, which automatically creates a subscription.
• Build a payment workflow using the API and Paddle.js, so customers can transition to paying.

How it works

Cardless trials work in a similar way to card-required trials, except that they can only be created using the API — not Paddle.js. To create a cardless trial, create a transaction using the API. Because no payment is required, the transaction is automatically completed and Paddle automatically creates a subscription for the customer.

A core part of the cardless trial lifecycle is collecting payment details from the customer. You should email customers with details about their signup and encourage them to convert throughout their trial period. To build a payment workflow, you can use the API and Paddle.js.

If customers don't enter payment details before the trial ends, Paddle automatically cancels the subscription.

Overview

Create a cardless trial in five steps:

1. Create a price with a cardless trial period

   Create a price for a product that has a cardless trial period. When added to a subscription, the customer doesn't need to enter a payment method when signing up.

2. Create a transaction for a customer

   Use the Paddle API to create a transaction for a customer, which automatically creates a subscription on completion.

3. Handle fulfillment

   Create a record for a cardless trial in your database, provision access to your app, and email the customer with details about their signup.

4. Incentivize customers to convert — optional

   Incentivize customers to convert by emailing them throughout their trial period.

5. Handle non-converting trials — optional

   Handle non-converting trials by giving customers a way to reactivate their subscription.

Before you begin

Add Paddle.js to your app or website

While cardless trials can't be created using Paddle.js, you need to use Paddle.js to collect a payment method from customers so they can convert to paying.

Include and initialize Paddle.js on a page in your app or website using your package manager or manually with a script tag.

Set your default payment link

You'll also need to:

• Set your default payment link under Paddle > Checkout > Checkout settings > Default payment link.
• Get your default payment link domain approved, if you're working with the live environment.

We recommend starting the domain approval early in your integration process, so your domains are approved for when you're ready to go-live.

Use one-page checkout

You can only present customers with a workflow to enter payment details for a cardless trial using one-page checkout. Multi-step checkouts aren't supported.

If you plan to use the checkout.url field in the transaction response to open a checkout for a cardless trial, you'll need to update your default payment link to use one-page checkout. To do this, pass variant with the value one-page as a checkout setting.

1Create a price

Model your pricing

In Paddle, a complete product is made up of a product and a price. Whether a subscription has a trial period is determined by whether the prices on the subscription have a trial period.

Prices can have two kinds of trial periods:

• Card-required trials

  Customers must enter payment details at signup, but aren't charged until the trial ends.

• Cardless trials

  Customers can sign up for a subscription without entering their payment details.

For this tutorial, we're going to create a price for a product that has a cardless trial.

Create products and prices

Dashboard support is coming soon. While in developer preview, you can only create or update prices with a cardless trial period using the API.

You can create products and prices using the Paddle dashboard or API, but you can only set a cardless trial period using the API while in developer preview.

We recommend creating a new price for cardless trials, rather than updating an existing price. This makes it easier for you to compare how cardless trials perform against card-required trials or no-trial prices over time.

Get or create a product

Prices relate to products. To create a price, you'll need to get the Paddle ID of an existing product to relate it to, or create a new product:

• Get an existing product

  Send a GET request to the /products endpoint to get a list of all products. Extract the Paddle ID of the product you want to relate the price to.

• Create a new product

  Send a POST request to the /products endpoint to create a new product. Extract the Paddle ID of the product you create.

Create a price with a cardless trial period

Build a request that includes information about your new price, then send a POST request to the /prices endpoint with the payload you built.

When creating a price, you must include the trial_period object with requires_payment_method set to false to make it a cardless trial.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1{
2  "product_id": "pro_01k5c106wy997av8jmz1qfng2q",
3  "description": "Monthly/seat with cardless trial",
4  "name": "Monthly (per seat)",
5  "trial_period": {
6    "requires_payment_method": false,
7    "interval": "day",
8    "frequency": 30
9  },
10  "billing_cycle": {
11    "interval": "month",
12    "frequency": 1
13  },
14  "unit_price": {
15    "amount": "1500",
16    "currency_code": "USD"
17  }
18}

Extract the price ID

If successful, Paddle responds with a copy of the new price entity. Extract the Paddle ID of the price you create — you'll need this to create a transaction for a subscription in the next step.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1{
2  "data": {
3    "id": "pri_01k5c14mgh9dc3wgk3vb23p0t7",
4    "product_id": "pro_01k5c106wy997av8jmz1qfng2q",
5    "type": "standard",
6    "description": "Monthly/seat with cardless trial",
7    "name": "Monthly (per seat)",
8    "billing_cycle": {
9      "interval": "month",
10      "frequency": 1
11    },
12    "trial_period": {
13      "interval": "day",
14      "requires_payment_method": false,
15      "frequency": 30
16    },
17    "tax_mode": "external",
18    "unit_price": {
19      "amount": "3000",
20      "currency_code": "USD"

2Create a transaction

Transactions are the central billing entity in Paddle. Paddle automatically creates a transaction when a customer opens a checkout, when a subscription renews, and for other subscription lifecycle events.

Subscriptions are automatically created when a transaction is completed. In a card-required workflow, when the customer completes their purchase using Paddle Checkout, the related transaction is automatically completed. At this point, Paddle automatically creates a subscription for the items on the transaction.

Cardless trials work in a similar way in that Paddle automatically creates a subscription for items on the transaction on completion. However, Paddle Checkout doesn't support cardless trials, so you must create a transaction manually using the API. Because there's no payment required, the transaction is automatically completed once it's billed.

Capture customer details

Transactions require a customer and address to say who the transaction is for, what currency they should be billed in, and how tax is calculated.

If users are signed in already, you can include the Paddle ID for the customer, address, and business of the signed in user in your request. If they're not signed in, you should create a new customer and address, and optionally a business:

1. Create a customer

   Customers hold information about the people and businesses that make purchases. Send a POST request to the /customers endpoint to create a new customer. Extract the Paddle ID of the customer you create.

2. Create an address

   Addresses hold billing address information for customers. Send a POST request to the /customers/{customer_id}/addresses endpoint to create a new address for a customer, passing the customer_id you extracted previously. Extract the Paddle ID for the address you create.

3. Create a business — optional

   Businesses entities hold information about customer businesses. Send a POST request to the /customers/{customer_id}/businesses endpoint to create a new business for a customer, passing the customer_id you extracted previously. Extract the Paddle ID for the business you create.

If you're building a signup workflow, we recommend using the Paddle.TransactionPreview() method (client side) or preview a transaction operation (server side) to present localized prices to your customer.

To prevent free trial abuse, consider blocking known disposable email address domains or implementing a CAPTCHA using a service like reCAPTCHA or Cloudflare Turnstile.

Create a transaction

Once you've captured the customer and address information, you can create a transaction by calling the Paddle API.

Build a request that includes the customer ID, address ID, business ID (optional), and an array of objects for each item. Items should be prices with trial periods where requires_payment_method: false.

Include the status field with the value billed to say that the transaction is finalized. Paddle automatically completes the transaction once it's billed, creating a subscription for you.

If you don't want to automatically complete the transaction, you can omit the status field. Paddle creates a ready transaction. Update a transaction to billed using the API to complete it.

1
2
3
4
5
6
7
8
9
10
11
12
13
1{
2  "items": [
3    {
4      "price_id": "pri_01k5c14mgh9dc3wgk3vb23p0t7",
5      "quantity": 10
6    }
7  ],
8  "customer_id": "ctm_01hx93hx7d5fj4f0ah1x4t22yq",
9  "address_id": "add_01hyjbr14xazf3hhgz79ysp6hj",
10  "currency_code": "USD",
11  "collection_mode": "automatic",
12  "status": "billed"
13}

Extract the transaction ID

If successful, Paddle responds with the new transaction entity. Its status is paid. This is an interim status while completed transaction processing happens — typically less than a second. During this time, the subscription is automatically created and Paddle creates an invoice for the transaction.

Extract the transaction ID from the response so that you can match this transaction to the subscription that Paddle creates.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1{
2  "data": {
3    "id": "txn_01k71zeadwbrvevb8czprm2r6c",
4    "status": "paid",
5    "customer_id": "ctm_01hx93hx7d5fj4f0ah1x4t22yq",
6    "address_id": "add_01hyjbr14xazf3hhgz79ysp6hj",
7    "business_id": null,
8    "custom_data": null,
9    "origin": "api",
10    "collection_mode": "automatic",
11    "subscription_id": null,
12    "invoice_id": null,
13    "invoice_number": null,
14    "billing_details": null,
15    "billing_period": null,
16    "currency_code": "USD",
17    "discount_id": null,
18    "created_at": "2025-10-08T13:16:19.504257826Z",
19    "updated_at": "2025-10-08T13:16:19.52223072Z",
20    "revised_at": null,

3Handle fulfillment

Paddle automatically creates a subscription for the items on the transaction once it's completed. Fulfillment for cardless trials is the same as for card-required trials or other kinds of subscriptions:

1. Create a webhook endpoint and create notification destinations for subscription and transaction events.

2. Listen for the transaction.completed webhook, using the transaction ID from the create transaction response to match the event to the transaction.

3. Extract and store the subscription_id and other relevant information from the payload, then grant the appropriate level of access to your app.

For full details on how to handle fulfillment, see Handle provisioning and fulfillment.

Determine if a subscription is a cardless trial

It's likely that you'll want to present customers with different screens in your app or website if they're on a cardless trial. For example, they won't have a payment method on file, so you might want to present them with a screen that asks them to enter their payment method.

You can determine that a subscription is a cardless trial by checking the following fields against a subscription entity:

You can also use the list subscriptions operation and pass the status, next_billed_at, and scheduled_change parameters to filter for cardless trials:

3Collect payment details

Customer portal support is coming soon. While in developer preview, you can't use customer portal to add payment details for cardless trials. You need to build your own payment workflow.

Paddle Checkout handles securely capturing card details or other payment method details. To convert cardless trials to paying, you'll need to build a payment method update workflow by getting a payment method update transaction, then passing it to Paddle.js to open a checkout for it.

Get a payment method update transaction

Payment method update transactions are a special kind of zero-value transaction that you can pass to Paddle.js to store a payment method.

To create a payment method update transaction, use the get a transaction to update payment method operation. You only need the subscription ID.

Extract the transaction ID and pass to Paddle.js

If successful, Paddle returns a new zero value transaction to collect for a payment method.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1{
2  "data": {
3    "id": "txn_01k71zrv404gcm17jgtxm8escg",
4    "status": "ready",
5    "customer_id": "ctm_01hx93hx7d5fj4f0ah1x4t22yq",
6    "address_id": "add_01hyjbr14xazf3hhgz79ysp6hj",
7    "business_id": null,
8    "custom_data": null,
9    "origin": "subscription_payment_method_change",
10    "collection_mode": "automatic",
11    "subscription_id": "sub_01k71zeayp3v7j86zy0k70wd22",
12    "invoice_id": null,
13    "invoice_number": null,
14    "discount_id": null,
15    "billing_details": null,
16    "billing_period": {
17      "starts_at": "2025-10-08T13:16:19.793Z",
18      "ends_at": "2025-10-08T13:16:19.793Z"
19    },
20    "currency_code": "USD",

Extract the transaction ID from the response, then use the Paddle.Checkout.open() method to open a checkout for it. Only one-page checkout is supported.

1
2
3
4
5
6
1Paddle.Checkout.open({
2  transactionId: "txn_01k71zrv404gcm17jgtxm8escg",
3  settings: {
4    variant: "one-page"
5  }
6});

You can also use the checkout.url field in the transaction response to automatically open a checkout for the transaction using your default payment link.

For more information, see Pass a transaction to a checkout

Activate immediately Optional

When a customer adds their payment details, they still have free access to your app until the end of the trial period. Some customers might want to start paying right away. You can activate a subscription immediately to cut the trial period short and start charging a customer for it.

Use the activate a trialing subscription operation in the Paddle API to build a workflow to activate a subscription immediately. We recommend providing a way for customers to make changes to their subscription, like adding or removing users or changing their plan, before activating a subscription.

For more details, see Activate a trialing subscription

4Incentivize customers to convert Optional

Paddle emails are coming soon. While in developer preview, Paddle doesn't email customers trial ending reminders for cardless trials. You need to send your own emails.

The barrier of entry for cardless trials is lower than for card-required trials, which means you'll typically see a higher signup rate compared to card-required trials. However, this often means a lower conversion rate since customers haven't committed to paying yet.

To incentivize customers to convert, we recommend emailing customers throughout their trial period:

5Handle non-converting trials Optional

By default, when a cardless trial ends and there's no payment method on file, Paddle automatically cancels the subscription.

It's common for customers to sign up for a trial but forget to add their payment details. Customers looking to reactivate a trial have a strong intent to buy, so you should build a way for them to reactivate rather than letting them sign up for another trial. Once reactivated, you can funnel them into a conversion workflow.

To reactivate non-converting trials, build a custom workflow to reinstate the subscription:

1. When a user whose trial expired returns to your app, get the previous subscription from Paddle or from your database.

2. Extract the items and details like the customer, address, business, and currency code from the previous subscription.

3. Create a transaction using the items and other information that you extracted. Set to billed to complete the transaction and create a new subscription.

4. As part of your fulfillment workflow, update the existing subscription record in your database to point to the new subscription in Paddle rather than creating a new one.

On reactivation, we recommend giving customers a shorter trial period and encouraging them to convert by offering a discount or other incentive. You might like to launch a checkout for the customer to collect payment right away, then transition the subscription to active.

Related pages