Base44 for Ecommerce: Shopify, Stripe, and Limits

Is Base44 right for ecommerce?

With caveats. Ecommerce is the vertical where Base44's general-purpose flexibility is most directly outcompeted by purpose-built tooling. Shopify exists. Medusa exists. WooCommerce exists. All three solve the boring parts of ecommerce — checkout, inventory, fraud, taxes, shipping rates — better than you can on Base44 in 2026.

Base44 wins ecommerce only in three narrow cases: workflows so unusual that purpose-built tools cannot bend that far, MVP validation where you need to test demand before committing to a full Shopify build, and integrated experiences where the store is one feature inside a larger custom app. Outside those cases, you are building infrastructure that already exists, while accepting platform fragility (Stripe regressions, App Store review risk, AI agent dropping checkout fixes) you would not face elsewhere.

Can you connect Base44 to Shopify?

Base44 can import a Shopify store once; it does not keep the two in sync. Its migration tool reads your store with your Shopify app credentials "during migration only", and Base44 states that "Nothing in your Shopify store will be modified" (Base44 docs: migrating an existing app, read 23 Sep 2026). Anything that must stay live between the two platforms is code you write.

The import takes five steps from the Base44 home page:

1. On the Base44 home page, click + on the prompt box, choose Migrate from another platform, then Shopify.
2. Enter your store URL in the https://mystore.myshopify.com format.
3. Paste the Client ID and Client Secret from your app in Shopify's Dev Dashboard (store name → View Dev Dashboard → your app → Settings → Credentials), then click Connect.
4. Pick the entities to bring over and click Import & Continue.
5. Review the prompt Base44 pre-fills and send it to start building.

Base44 lists what comes across: products, orders, customers, collections, pages, articles (blog posts), discounts and the frontend theme code, with the storefront URL preserved. It imports 100 items from each entity first so you can preview the app, then prompts you to migrate the rest. The Shopify list does not mention metafields, installed Shopify apps or checkout customisations, so check anything your store keeps there before you treat the import as complete.

After the import, the Base44 copy and the live Shopify store are separate systems. An order placed on Shopify tomorrow does not reach Base44 unless you build the sync, and Base44's connector catalogue does not list Shopify (read 23 Sep 2026). For an API like that, Base44's docs point to backend functions, which "run on the server, so you can safely store API keys and secrets as environment variables without exposing them to the browser" (Connect to third-party APIs).

Pattern	What Base44 documents	When it fits
One-time import	Migrate from another platform → Shopify; read-only, "during migration only"	You are moving the store onto Base44 and switching Shopify off
Ongoing sync	No Shopify connector; a backend function calls Shopify's Admin API with keys held as environment variables	Shopify stays the system of record and Base44 needs live orders or stock
Shopify store, Base44 companion app	The same backend-function route, reading only what the companion app needs	A B2B portal, subscription dashboard or fulfilment tool that Shopify's apps do not cover, while checkout stays on Shopify

When Shopify stays, the third pattern is the right one: Shopify keeps checkout, fraud screening and taxes, and Base44 builds the unusual workflow around them. If you already run a sync and orders drift between the two systems, the $497 production audit checks the backend functions and webhook handling that sync runs on.

What you can build

Ecommerce shapes that fit Base44:

• Single-brand DTC stores with a small catalog — you control every page, every product, every step. Useful when your brand requires deep visual customization that Shopify themes do not allow.
• Subscription box products — recurring billing is Stripe, fulfillment scheduling is a backend function, customer portal is a few collections. Base44's strengths line up well.
• Digital goods (PDFs, courses, downloads) — no inventory, no shipping, no fulfillment. Just gated downloads after Stripe payment. This is Base44's sweet spot.
• Limited-drop merchandise — small SKU count, time-bound sales, queue-based purchase flow. The unusual workflow makes off-the-shelf tools awkward.
• B2B catalog with quote-request — no online checkout, just a catalog with "request quote" forms. Sales process happens elsewhere. No PCI scope on the store itself.
• Validation stores — you want to know if a product will sell before committing to a Shopify build. Throw up a Base44 store, run paid traffic, measure conversion, then decide.

What does not fit:

• Large SKU catalogs — Base44's collection scaling and search are inadequate.
• High-frequency flash sales — race conditions on inventory will create oversells.
• App-first stores — Base44's store build is a web-view wrapper with no in-app purchases and no full offline mode yet, so a store whose value lives in the native app needs a native stack.
• Marketplaces with multiple sellers — see Base44 for marketplace.
• International stores with multi-currency, multi-tax — too much regulatory plumbing to build by hand.
• Stores with offline POS integration — not Base44's domain.

Critical patterns for ecommerce

1. Stripe Checkout, not Stripe custom

For PCI scope reduction and reliability, use Stripe Checkout (the hosted page) rather than Stripe Elements (embedded in your site) or custom Stripe integration:

// Backend function: create-checkout-session.ts
const session = await stripe.checkout.sessions.create({
  payment_method_types: ['card'],
  line_items: cart.items.map(item => ({
    price_data: {
      currency: 'usd',
      product_data: { name: item.name, images: [item.image_url] },
      unit_amount: item.price_cents,
    },
    quantity: item.quantity,
  })),
  mode: 'payment',
  success_url: `${baseUrl}/orders/${orderId}/success`,
  cancel_url: `${baseUrl}/cart`,
  metadata: { order_id: orderId, user_id: userId },
});

return { redirect_url: session.url };

Stripe handles cards, fraud, 3DS, Apple Pay, Google Pay. Your store only handles the cart and the post-payment fulfillment trigger. PCI scope: SAQ-A. Reliability: high.

Base44's own terms make keeping card numbers out of your app a requirement, not just good hygiene. The terms of service (last updated June 22, 2026) say no sensitive data "such as protected health information or credit, debit or other payment card data" will be shared with the platform "other than if expressly agreed by the Company in prior writing and the appropriate agreement is in place" (base44.com/terms-of-service). A custom form that posts raw card numbers into a backend function or an entity breaks that clause; the hosted Checkout page keeps them on Stripe. Base44's payments guide points the same way: its January 2026 Stripe flow (Builder plan and above) says each flow "should send a logged in person to Stripe Checkout" and confirm the payment on the success page "instead of relying on webhooks alone" (Setting up Stripe). The Payments tab Base44 added on 17 August 2026 offers Base44 Payments (powered by Wix) as the alternative to Stripe (Base44 changelog).

2. Inventory: backend-function transactions, not client-side

Never decrement inventory from the frontend. Pattern:

// Backend function: place-order.ts
async function handler(req) {
  const { cart_items, user_id } = await req.json();

  // 1. Read inventory + lock conceptually
  const products = await db.from('products')
    .select('id, inventory_count, price_cents')
    .in('id', cart_items.map(i => i.product_id));

  // 2. Validate inventory
  for (const item of cart_items) {
    const product = products.find(p => p.id === item.product_id);
    if (!product || product.inventory_count < item.quantity) {
      throw new Error(`OUT_OF_STOCK:${item.product_id}`);
    }
  }

  // 3. Create order in pending state
  const order = await db.from('orders').insert({
    user_id, status: 'pending_payment',
    subtotal_cents: calculateTotal(cart_items, products),
  }).single();

  // 4. Decrement inventory (with optimistic concurrency check)
  for (const item of cart_items) {
    const updated = await db.from('products')
      .update({ inventory_count: { decrement: item.quantity } })
      .eq('id', item.product_id)
      .gte('inventory_count', item.quantity);
    if (!updated) {
      // Roll back: delete order, restore inventory of already-decremented items
      await rollback(order.id, decrementedItems);
      throw new Error('CONCURRENT_OVERSELL');
    }
  }

  // 5. Create Stripe Checkout session, return URL
  return { checkout_url: await createStripeSession(order, cart_items) };
}

Even this pattern has races on extremely high-write SKUs. For limited drops, add a queue collection that serializes purchase attempts.

3. Webhook reliability: external proxy

Stripe webhooks fire on checkout.session.completed, charge.refunded, invoice.payment_failed. Base44's webhook receiver only fires reliably when users are active. For ecommerce this is a revenue risk. Pattern:

Stripe -> Cloudflare Worker (verify signature, dedupe by event.id)
       -> Cloudflare Worker writes event to Base44 'stripe_events' collection
       -> Worker triggers Base44 backend function with auth header
       -> Backend function processes (mark order paid, send receipt, trigger fulfillment)
       -> If Base44 is down, Worker queues + retries (Cloudflare Queue)

This costs $5–10/month and closes the window in which paid orders go unrecorded.

4. Email: transactional from day one

Order confirmation, shipping notification, receipt, refund confirmation — all transactional, all required, all easy to forget. Set up Postmark or Resend on day one and route every customer-facing email through a single backend function with a template. Do not use Base44's built-in email; deliverability and template flexibility are both inadequate.

5. Mobile: know what Base44's store build is

Since 3 February 2026 Base44 generates App Store (.ipa) and Google Play (.aab) files itself from the editor's Mobile app tab; downloading them requires the Builder plan or higher. The result is a web-view wrapper around your published app, with push notifications configured when the files are generated (Base44 docs: submitting to app stores). You still upload the files from your own App Store Connect and Google Play Console accounts. For a store, three rules decide the outcome:

• Physical goods can keep Stripe. Apple's Guideline 3.1.3(e) says an app selling physical goods or services used outside the app "must use purchase methods other than in-app purchase to collect those payments". Base44's docs agree: for physical goods, "Using Stripe is allowed in the app stores."
• Digital goods cannot. Base44's wrapper does not support in-app purchases yet, and its docs say RevenueCat and Capacitor purchase plugins "do not work". Sell PDFs, courses and downloads on the web version of your store and let the app show what the customer already owns.
• Minimum functionality is the real rejection risk. Apple's Guideline 4.2 reads: "If your app is not particularly useful, unique, or “app-like,” it doesn’t belong on the App Store." A wrapper that opens only your storefront's URL has to give shoppers something the website does not, and push notifications are the one native feature Base44's docs list for it.

If none of that is worth the review cycle, ship a Progressive Web App. Add a manifest.json, service worker, "Add to Home Screen" prompt. This works on iOS and Android and has no App Store dependency. If you do take the store route, see our walkthrough on publishing a Base44 store app to mobile.

Limitations and gotchas

Limitation	Ecommerce impact	Mitigation
Stripe regressions across updates	Silent order loss	Stripe integration breakage guide + monitoring
Webhooks need active users	Failed payment + refund flows broken	External Cloudflare Worker proxy
App Store Guideline 4.2 (minimum functionality)	A wrapper that only repeats the storefront risks rejection	App Store rejection guide; add app-only value or ship a PWA
Inventory race conditions	Oversells on high-write SKUs	Backend function with optimistic concurrency
No native cart abandonment	Lose recoverable revenue	Build it: scheduled task scans incomplete checkouts
No native taxes / shipping rates	Manual or third-party (TaxJar, EasyPost)	Add a backend function that calls Avalara/TaxJar
AI agent rewrites checkout	Tested checkout breaks unprompted	Snapshot-and-scope workflow
No Shopify-style theme system	Brand customization is full custom build	Embrace it or use Shopify
5,000-item request limit	Bulk product imports break	Pagination + queue
No SLA below Enterprise	Outages directly = lost revenue	Status page polling + degraded checkout
Product-page SEO is partly manual	Base44 serves crawlers a prerendered version of each page, but sets no per-page meta descriptions or Product schema by default, and its automatic unique titles cover only URLs without parameters such as ?id=123	Write descriptions on the SEO & GEO page, add Product JSON-LD yourself, check product URLs in Search Console; see why a Base44 store is missing from Google

The two that bite hardest: silent Stripe webhook regressions (you discover them when a customer emails asking why their order never confirmed) and the App Store rejection (you discover it at review, after the build is finished).

Real-world example architecture

An example 200-SKU DTC store on Base44:

Collections:
- users               (customer accounts, optional guest checkout)
- products            (SKU, price, inventory_count, images, description)
- categories          (product categorization)
- carts               (cart_id, user_id or anonymous_id, items, expires_at)
- orders              (order_id, user_id, status, subtotal, tax, shipping, total)
- order_items         (order_id, product_id, quantity, price_at_purchase)
- shipping_events     (order_id, status, carrier, tracking, ts)
- stripe_events       (raw webhook events from Cloudflare Worker)
- email_events        (sent receipts, abandonment emails, etc.)
- audit_events        (admin actions on orders)

External services:
- Stripe Checkout       -> payments
- Cloudflare Worker     -> webhook reliability
- Postmark              -> transactional email
- ShipStation or EasyPost -> shipping labels + tracking
- TaxJar or Avalara     -> tax calculation
- Sentry                -> error tracking

Key flows:
- Add to cart    -> cart row update
- Checkout       -> place-order backend function -> Stripe Checkout redirect
- Payment success -> Stripe webhook -> Cloudflare Worker -> mark order paid
                                                        -> trigger fulfillment
                                                        -> send receipt email
- Fulfillment    -> admin clicks "ship" -> ShipStation API -> tracking event
- Refund         -> admin issues refund -> Stripe API -> webhook -> order updated

This stack ships in 4–6 weeks for a single-brand store, and runs reliably until scale or App Store pressure forces migration.

Cost to ship

For a 200-SKU DTC store doing $30k MRR:

Line item	Monthly	One-time
Base44 Pro or Elite plan (monthly billing)	$100–200	—
Cloudflare Worker	$5	$300
Stripe fees (~$30k MRR)	$880	—
Postmark	$50	—
ShipStation	$30–100	—
TaxJar	$20–50	—
Sentry	$26	—
Build (catalog, checkout, admin, hardening)	—	$9,000–15,000
Total	~$1,110–1,310/mo incl. Stripe fees	~$9,000–15,000

The Base44 line uses the published plan prices: Pro is $100/month with 500 message credits and Elite $200/month with 1,200 on monthly billing, and annual billing "saves 20%" (base44.com/pricing, read 23 Sep 2026). Base44's pricing page documents no credit top-up; when you hit the monthly limit, the documented step is a higher plan.

Compare to Shopify: $39–399/month on the Basic to Advanced plans billed monthly, plus card rates from 2.5–2.9% + 30¢ (shopify.com/pricing, read 23 Sep 2026), plus apps ($50–200/month) and a theme ($0–500). Operational cost: $200–800/month total. Build cost: $0–3,000 (theme customization). Shopify is materially cheaper to operate; Base44 wins only when you need workflow flexibility Shopify cannot offer. To price the Base44 line for your own plan tier, edit pace and integrations (Stripe, email, SMS), use the Base44 cost-per-month calculator.

Migration off-ramp

The right migration target depends on what you outgrew Base44 for:

• Outgrew flexibility limits at scale — Medusa.js on Vercel + Postgres (open-source headless commerce, full customization, no platform lock-in).
• Outgrew operational tolerance — Shopify Plus + Hydrogen (managed checkout, app ecosystem, scale-tested).
• Need iOS native — React Native or Flutter app with Shopify storefront API or custom backend.

Migration playbook is in Base44 to Next.js + Supabase for the headless path, or run a Shopify migration through Shopify's import tools (Stripe customer carry-over is the main pain point). Hired out, the migration is fixed-price on our published migration tiers, $6,000, $12,000 or $25,000+ by tables, roles and tenancy, scoped to your catalog before work starts.

Get this scoped

If you are building DTC ecommerce on Base44 and want to know whether you should harden the current build, migrate to Shopify, or rebuild headless, our $497 production audit gives you a written verdict in one business day, and the fee is credited in full against any fix, build, migration or written-recommendation engagement booked within 30 days. Includes the Stripe webhook reliability check, inventory consistency review, mobile distribution analysis, and SEO audit.

If you are at the build stage and want it done right, our standard build engagement ships a hardened Base44 ecommerce store in 4–6 weeks, fixed-price.

Book a 15-minute call to scope your store

Related

• Solutions hub — every Base44 vertical fit verdict in one matrix.
• Base44 for SaaS: subscription patterns
• Base44 for marketplaces: two-sided commerce
• $497 production audit — written ecommerce-readiness verdict on Stripe, inventory, and SEO.
• Stripe integration breaks after updates
• App Store rejection — no StoreKit support
• Webhooks require active users: the dunning gap
• Base44 store pages not showing in Google
• Migrate Base44 to Next.js + Supabase
• Written by the Lead Engineer at Base44Devs from production ecommerce builds.