Monto Simple Subscriptions

A Webflow Ecommerce checkout charges a customer once. There is no native way to bill that same customer again next week or next month, so subscription boxes and recurring service packages both need a separate recurring-billing layer. Webflow switched off native User Accounts and Memberships on all sites on January 29, 2026, and the APIs went with the feature, so that surface is retired and cannot be used for gated access. Sites that need customer logins now run them through Memberstack or Outseta, and any tutorial still pointing at Memberships is out of date.

Monto Simple Subscriptions fills the billing gap by attaching recurring plans to standard Webflow Ecommerce products. Subscription products live inside the products collection and sell through the existing cart and checkout, alongside one-time products in the same order. Stripe charges for each renewal after the initial purchase, and subscribers pause, cancel, and update payment details through a self-service portal.

The integration fits store owners selling consumables on a repeat-delivery schedule, SaaS businesses offering discounted trial periods, and agencies billing monthly service packages. Online course access and subscription boxes are documented use cases too. Teams moving an established subscription business onto Webflow can also migrate existing Stripe subscribers, which Monto gates behind its Enterprise plan.

How to integrate Monto Simple Subscriptions with Webflow

What is Monto Simple Subscriptions? It is a recurring billing app built for Webflow Ecommerce. It links subscription plans to Webflow product variants, supports mixed carts, fixed-term plans, and reduced-price trials, and processes every recurring charge through Stripe. Stripe is the only supported payment processor, and PayPal is not supported. Monto's published pricing runs free up to 10 active subscribers, then $19 per month up to 100 and $49 per month up to 250, with no Monto transaction fee on top of Stripe's own processing charge.

Teams pair Monto with Webflow when they want recurring revenue without leaving the native checkout. The customer buys once at checkout, Monto creates the Stripe subscription in the background, and there is no external payment page to maintain.

Much of the site-side work around that setup can now run through an agent instead of the Webflow UI. Webflow's MCP server exposes the platform's APIs as tools an AI client can call, including reading and writing site-level custom code, which is exactly where the Monto script lives, and creating or updating CMS items that mirror subscription state. Agents operate inside your existing Webflow permissions and roles, each site can carry its own Agent Instructions, and every change an agent makes is recorded in the site activity log. Webflow's MCP documentation does not list Ecommerce order data among its tools, so order and subscription reconciliation still runs through the APIs covered below.

Setup itself has a fixed shape. The Monto app handles site authorization and plan configuration without any code. Getting those plans working on a published site also needs the Monto global script, installed as site-wide custom code. Teams that want order and subscription data inside their own systems add a third path, the Webflow and Monto APIs, which calls for server-side development.

Install the Monto app

Monto ships one Marketplace listing covering its whole ecommerce suite, so the same install also carries Monto Reviews and its other apps. Monto connects to your site through OAuth, and you authorize that connection from the Monto dashboard, where plan configuration happens too. You need a Webflow Ecommerce site and a Stripe account first, and both the site and the Monto app must use the same Stripe account.

To set up the integration:

1. In the Monto dashboard, open the site dropdown and select Add Site.
2. Select your Webflow site on the authorization screen, click Authorize App, and enter your store name.
3. Connect Stripe on the subscriptions configure page at monto.io/ss/configure.
4. In Webflow, follow Monto's Subscribe and Save guide, linked from the tutorial button above, to add a product with subscription frequency variants such as Weekly and Monthly plus a one-time purchase option.
5. Publish your site. This has to happen before you create the Monto plan.
6. In Monto, go to Subscriptions > Plans > Add Plan, select the product and subscription variant, and match the frequency and price to the Webflow variant.

Once plans are attached, the app supports:

• Mixed-cart checkout: Subscriptions sell alongside one-time products in the same order, through the same Webflow cart your store already uses.
• Subscribe and Save variants: A recurring variant priced below the one-time option sits on the same product page, so the discount is visible at the point of choice.
• Fixed-term plans: A plan either cancels after a set number of billing terms or renews indefinitely until the subscriber cancels it themselves.
• Reduced-price trials: A lower introductory price runs for a defined period and then converts to full subscription pricing without any action from the customer.
• Subscriber portal: Stripe's portal or Monto's own handles pausing, resuming, canceling, and payment updates, so those requests never reach your inbox.

Do not attach a plan to the one-time purchase variant, and never disconnect Stripe from Monto: disconnecting deletes all subscription data held in Monto with no recovery path. Install the global script next, because Monto's apps rely on it to work on a published site.

Add the Monto global script with custom code

Monto's apps reach a Webflow site through a single site-wide global script, and without it many of them will not function as intended. The script goes in the head of your site through custom code in head and body tags. That method requires a paid Site plan or a paid Workspace plan.

To install the script:

1. Copy your site's script from the setup page at monto.io/setup.
2. In Webflow, open Site Settings > Custom Code.
3. Paste the script into the Head Code section and save.
4. Publish your site.

Each Webflow site gets a unique script, so never reuse one script across sites. Custom code sections accept HTML, CSS, and JavaScript only; server-side code does not run there.

Use a Code Embed element for page-level code

A Code Embed element injects code on a single page instead of site-wide. Open the Add panel, drag in a Code Embed element, paste your code, and click Save. The same plan requirements apply. Install the Monto global script site-wide in Head Code rather than through a Code Embed.

Build with the Webflow and Monto APIs

Developers work directly with both APIs to track renewals and reconcile orders, and to tie Webflow CMS updates to subscription status. This path requires server-side development. Monto authenticates every request with an api_key query parameter, and your key sits in the Monto dashboard at monto.io/shop/api. Monto's Simple Subscriptions API is pull only and documents no outbound webhooks, so status changes are retrieved by polling rather than pushed to you.

Order and subscription work draws on a small set of endpoints:

• Monto's API: The Monto API collection documents three endpoints in total, covering authentication, order creation, and subscription lookup by order ID.
• Webflow request auth: Data API authentication covers tokens and scopes for every call you make against the Webflow API.
• Ecommerce and CMS reads and writes: The orders endpoint returns purchase data, and CMS collection items endpoints create the records you use to represent a subscriber.
• Event delivery: Webflow webhooks fire real-time events such as ecomm_new_order and ecomm_order_changed, which is how you learn about a purchase without polling Webflow.

Those four pieces cover the two jobs that come up most often: confirming that a subscription exists for a new order, and recording renewal orders that Webflow never sees.

Confirm subscription status for an order

Webflow's ecomm_new_order webhook fires on the initial purchase, and its payload carries the order ID you need to query Monto. The payload includes orderId, customerInfo, purchasedItems, and stripeDetails.

To wire it up:

1. Register a webhook with POST https://api.webflow.com/v2/sites/{site_id}/webhooks and set triggerType to ecomm_new_order. Registering the webhook uses the sites:write scope; reading the order data afterward uses the ecommerce:read scope.
2. In your handler, extract orderId from the webhook payload.
3. Call GET https://api.monto.io/orders/{order_id}/subscriptions?api_key=... to fetch the subscriptions created for that order.

The response returns each subscription's stripe_id, status, and created_at, and a single order can return more than one subscription. A status of "trialing" is expected on new orders, since Monto assigns a trial for one billing interval to avoid double-charging. The endpoint returns 401 for an invalid key, 404 for an unknown order ID, and 429 when you call it too often.

Register renewal orders in Monto

Renewals do not create new orders on your site, so renewals driven by external systems have to be recorded through Monto's Create Order endpoint. Orders created this way appear only in Monto's order panel, never in Webflow.

Send POST https://api.monto.io/orders?api_key=... with a JSON body in this shape:

{
  "order_id": "abc",
  "customer": {
    "name": "John Doe",
    "email": "johndoe@monto.io"
  },
  "status": "fulfilled",
  "items": [
    {
      "slug": "first-product"
    },
    {
      "slug": "second-product"
    }
  ]
}

Three fields decide what happens next. order_id can be any unique identifier, and reusing one overwrites the earlier submission. status accepts "pending" or "fulfilled" and nothing else, defaults to "pending" when omitted, and only "fulfilled" triggers Call To Review emails, which still requires the site to be subscribed to Monto Reviews with those emails enabled in your configuration. Each slug under items must match the corresponding Webflow collection item, which is how Monto pulls the product name and image. A successful call returns HTTP 200 OK with an empty body.

For CMS sync, poll the Get Subscriptions endpoint on a schedule, then write status changes to Webflow with PATCH /v2/collections/{collection_id}/items/live through the update live items endpoint. Monto also runs a full sync on every shop every 24 hours, which recovers dropped webhooks and subscription records that were missed. Build polling for anything that needs to update faster than that.

What you can build with the Monto Simple Subscriptions Webflow integration

Integrating Monto Simple Subscriptions with Webflow lets you sell recurring products through the native cart and checkout, with no external payment page and no second storefront to keep in sync.

• Subscription box storefronts: Monthly or quarterly physical deliveries with trial pricing and automated billing, such as a consumables club with shipping charged on every renewal.
• Subscribe and Save product pages: Product pages where a discounted Monthly variant sits next to a full-price one-time option, both purchasable in the same cart with other products.
• SaaS and course storefronts: Recurring software licenses or course access plans with reduced-price trials that convert to full pricing, with downloads gated through Monto's free Customer Portal app.
• Installment payment plans: Fixed-term plans repurposed so customers pay for a large purchase over time with no credit checks, which Monto documents as a workaround rather than a real payment plan system.

If renewal tracking and CMS updates matter more to you than the no-code path, the API route covers both. Read Stripe Checkout in Webflow for the payment groundwork, then connect the MCP server so your AI tools can handle the CMS side of that work directly.