Contract, Checkout
A Contract (Checkout) in Salesforce Commerce is the contract record created at the end of a B2B Commerce or Subscription Management checkout flow when the purchase involves recurring billing or a multi-period commitment.
Definition
A Contract (Checkout) in Salesforce Commerce is the contract record created at the end of a B2B Commerce or Subscription Management checkout flow when the purchase involves recurring billing or a multi-period commitment. The checkout captures the line items, pricing, term length, billing schedule, and customer signatures, then writes them to a Contract record (standard or custom) that downstream finance and customer success teams operate against.
The pattern exists because B2B Commerce purchases are often not one-shot transactions. A buyer commits to a 12-month subscription, an annual support contract, or a multi-year SaaS deal. The checkout writes the immediate Order, but it also writes the longer-lived Contract that governs renewals, billing cycles, and modifications throughout the term. Salesforce Revenue Cloud and Subscription Management both rely on this pattern; older B2B Commerce orgs sometimes use a custom Contract object instead of the standard.
How a Contract is created during Salesforce Commerce checkout
The Commerce checkout flow that creates a Contract
A B2B Commerce checkout walks the buyer through cart, shipping (if physical), billing, terms acceptance, and payment. When the cart contains subscription or recurring billing line items, the final step writes both an Order and a Contract. The Contract holds the term length, billing schedule, and customer commitment; the Order holds the immediate fulfillment metadata.
Standard Contract vs custom Contract objects
Salesforce ships a standard Contract object with fields like Start Date, End Date, Contract Term (in months), Status, and Account. Subscription Management and Revenue Cloud sit on top of this standard object. Older B2B Commerce implementations sometimes use a custom Contract object built for that org-specific billing needs. New implementations should use the standard plus Revenue Cloud extensions; custom contracts are harder to maintain.
Contract Line Items and the relationship to Order Products
A Contract typically has Contract Line Items (one per subscription product), and an Order has Order Products (one per fulfilled line). The two are mirrored at checkout: each subscription Order Product corresponds to one Contract Line Item with matching product, quantity, and pricing. Non-subscription line items (one-shot purchases of physical goods, for example) appear only on the Order, not the Contract.
Subscription Management and the recurring billing pattern
Subscription Management is the Salesforce module that takes a Contract from checkout and runs the lifecycle: monthly or annual billing runs, mid-term modifications (add seats, change tier), renewal proposals, and termination. Without Subscription Management, the Contract sits dormant after checkout and downstream billing has to happen in a separate tool.
Customer signatures and the contract document
Many B2B checkouts include a signed Contract document (PDF) attached to the Contract record. Salesforce integrates with DocuSign, Adobe Sign, and similar tools through the checkout flow so the buyer signs at checkout and the signed PDF lands as a Content Document on the Contract. Some flows also store the signed terms version as a Content Version pinned to the Contract.
Revenue Cloud and the integration with billing
Revenue Cloud (the successor to CPQ plus Billing) reads from the Contract created at checkout and feeds the billing engine. Invoice generation, revenue recognition, and ASC 606 compliance reporting all key off the Contract. A correctly populated Contract at checkout is what makes the rest of the revenue process work without manual intervention.
Common gotchas at checkout
The most common implementation errors are missing Contract Term fields (Subscription Management defaults to 12 months if missing, which is wrong for non-annual deals), missing customer signatures (downstream billing reaches out asking why), and mismatched line items between Order and Contract (one fulfilled item that does not appear in billing). Test the checkout flow for each subscription product separately.
How to configure Contract creation in Salesforce Commerce checkout
Most of the work happens in Commerce checkout flow configuration. The Contract write is downstream of the checkout but driven by what the buyer selects.
- Enable Subscription Management or Revenue Cloud
Setup, search for Subscription Management. Enable. License is required separately; check entitlements.
- Configure subscription product types
For each product that should generate a Contract at checkout, set the product configuration in Product2 or in the Revenue Cloud Product Catalog with Recurring Billing = true and a default Contract Term.
- Build or customize the Commerce checkout flow
Use Commerce Cart Checkout flow templates. Add a step at the end that calls the Subscription Management invocable action to create the Contract from the Cart state.
- Test with each subscription product
Walk through checkout for each subscription product type. Confirm the Contract record is created, Contract Line Items are populated, and the signed document is attached.
- Set up Contract lifecycle automation
Build the renewal, modification, and termination flows on the Contract object. Subscription Management ships templates for these; customize per business rules.
- Test edge cases
Multi-product carts mixing subscription and one-shot items. Bulk discount logic that should reflect on the Contract. Refund or cancellation immediately after checkout.
- Contract Term defaults to 12 months in Subscription Management if not set. Multi-year and monthly deals need explicit Contract Term values at checkout.
- Order Product and Contract Line Item are separate records. Reconciliation between them is the most common source of billing errors; make Apex tests cover the match.
- Customer signature workflows must complete before the Contract is marked Active. Activating without a signature creates audit problems downstream.
- Mid-term modifications create new Contract Line Items or update existing ones depending on configuration. Decide the pattern early; switching later creates data drift.
- Multi-currency contracts inherit the currency of the buyer Account, not the user creating the contract. Wrong inputs cause wrong invoices.
Trust & references
Cross-checked against the following references.
- B2B Commerce OverviewSalesforce Help
- Subscription Management OverviewSalesforce Help
Straight from the source - Salesforce's reference material on Contract, Checkout.
- Revenue Cloud OverviewSalesforce Help
- Contract Object ReferenceSalesforce Developers
About the Author
Dipojjal Chakrabarti is a B2C Solution Architect with 29 Salesforce certifications and over 13 years in the Salesforce ecosystem. He runs salesforcedictionary.com to help admins, developers, architects, and cert/interview candidates sharpen their fundamentals. More about Dipojjal.
Test your knowledge
Q1. When is a Contract created during Checkout?
Q2. Why link checkout to a Contract record?
Q3. What does the Contract typically capture?
Discussion
Loading discussion…