AI & Automation

Make.com Ecommerce Automation: Sending Orders and Leads Into StoreChart

Written by The StoreChart team7 min read

In short

StoreChart connects to Make.com in one direction: a Make scenario sends data into StoreChart through an inbound webhook URL. The custom webhook creates orders, the lead webhook creates leads, and a sales-channel webhook creates orders credited to an ambassador or distributor. StoreChart does not send its own events out to Make, so every scenario starts in another app.

Make.com ecommerce automation with StoreChart runs in one direction, and knowing that up front saves hours of debugging. Most Make.com guides for online stores assume the store platform announces every event and Make reacts to it. With StoreChart the flow runs the other way: each inbound webhook has its own secret URL, and a Make scenario posts orders, leads or sales-channel orders to it. Once the record exists, StoreChart's own WhatsApp automations, customer records and reports take over. This guide covers what each webhook accepts, five scenarios worth building, where native automations are the better tool, and the mistakes that cause rejected or duplicate records.

Data flow between Make and StoreChart

Data flows into StoreChart, never out of it to Make. StoreChart exposes three kinds of inbound webhook, and each one creates a specific type of record:

  • Custom webhook: creates orders in one store.
  • Lead webhook: creates leads in a lead channel.
  • Sales-channel webhook: creates orders credited to an ambassador or distributor.

Custom webhook for orders

A custom-webhook integration belongs to one store and gives you a URL with a secret token. It accepts a JSON order:

  • Required fields: id, status, total, date_created and at least one line item.
  • Line item fields: name, quantity, price and product id, plus an optional SKU.
  • Optional fields: customer name, email and phone, shipping details, coupon code and discount, payment method and notes.

When the order arrives, StoreChart:

  • Matches the customer: by phone first, then by email, and creates a new customer only when neither matches.
  • Matches products: each line item by SKU, creating the product if it doesn't exist yet.
  • Sets the status: from the payload, or from a fixed default status you set on the integration.
  • Logs the request: successful or not, in integration logs, and raises a new-order notification.

Lead webhook

A lead channel has its own URL. A lead needs at least a phone, a name or an email.

  • Fields: name (as one field or as first and last name), phone, email, message, source detail and estimated value.
  • Custom fields: any field you define for that channel.
  • Duplicate check: an identical submission that arrives again a moment later is merged into the first one.
  • Logging: every request, including rejections, is recorded against the channel.

Sales-channel webhook

A sales channel has its own token too, and orders posted to it are credited to that channel:

  • Ambassador channel: when the channel has a commission rate, StoreChart records the commission on each order.
  • Distributor channel: StoreChart enforces the channel's product selection and the channel's own prices.

What is not available

StoreChart does not notify Make when something happens inside StoreChart. There is no StoreChart event feed for a scenario to listen to, so a scenario must start in the app where the event happens.

Connecting a Make scenario to a webhook

Setting up the connection takes four steps and no code:

  1. In StoreChart, create the receiving endpoint: a custom-webhook integration for orders, a lead channel for leads, or a sales channel for partner orders. Copy its URL.
  2. In Make, add the HTTP "Make a request" module as the last step of the scenario. Set the method to POST and send the body as raw JSON with the application/json content type.
  3. Map the fields from the earlier modules to StoreChart's field names: customer_phone, line_items, first_name and so on.
  4. Run the scenario once with real data and read the response.

What the response tells you:

  • Success: returns the new order number or lead id.
  • 422: lists the missing or invalid fields.
  • 401: the token is wrong or the integration is inactive.
  • 429: the endpoint's limit of 1,000 requests per hour was reached.

Make.com ecommerce automation: 5 scenarios

These scenarios all start in another system and end in StoreChart:

  1. Website or landing-page form to lead. The form tool's module starts the scenario, and the HTTP module posts name, phone and message to a lead channel. The lead lands in StoreChart with its source recorded.
  2. Ad lead forms to lead. Leads from an ad platform's lead form go to a dedicated lead channel, so you can compare channels by source.
  3. Sheet rows to orders. Phone orders typed into Google Sheets by staff become real StoreChart orders, matched to existing customers by phone.
  4. Another sales platform to orders. Orders from a marketplace or booking tool that Make supports, and StoreChart doesn't connect to natively, are posted to a custom webhook so they appear with the rest of your orders.
  5. Partner form to channel order. An ambassador's order form posts to that ambassador's channel URL, so the commission is recorded automatically.

Example: 200 phone orders a month

Say a store's staff retypes phone orders from a shared sheet:

  • Volume: 200 phone orders a month.
  • Time: about three minutes each, so roughly ten hours of typing a month, plus the typos.
  • After scenario 3: a sheet row becomes an order, and the customer match happens automatically.

The figures in this article's examples are illustrative only and do not reflect actual customer data.

Native automation or a Make scenario

Use Make to get data in, and StoreChart's native rules for what happens next. Events are captured when the record is saved, so an order that arrives through a webhook runs the same rules as a WooCommerce order.

WhatsApp automation triggers

StoreChart's WhatsApp automations start on one of these events:

  • Orders: an order is created, or an order's status changes.
  • Timing: a set time has passed after an order.
  • Leads: a lead is created, or a lead's status changes.
  • Conversations: an incoming WhatsApp message arrives.

Actions and run history

Each rule can take one of these actions:

  • Template: send an approved WhatsApp template.
  • Free-form message: send it inside WhatsApp's 24-hour window.
  • AI agent: hand the conversation to the AI agent.

Every run is kept in the run history with the reason it sent or skipped. A scenario that posts a lead and then sends its own WhatsApp message duplicates work StoreChart already does, and it adds a second place for things to break.

Tip

Keep the scenario as short as possible: collect, map, post. Put the follow-up messages in StoreChart, where the run history shows exactly what each customer received.

Common mistakes: rejected and duplicate records

Most failures come from the payload, not the connection:

  • Missing required fields. An order without status or date_created, or with an empty line_items array, is rejected with a 422 that names the field.
  • A reused or constant id. The order id is the duplicate check for each store. If a scenario always sends the same value, every order after the first comes back as "already exists." Map the source system's own id.
  • No SKU. A line item without a SKU becomes a separate product keyed on its product id. Send the SKU you use in inventory so orders attach to the right product.
  • Old dates. A date_created more than an hour in the past, or in the future, is replaced with the time the order was received. Webhooks are for new records; use CSV import for history.
  • Partial phone numbers. Customers are matched by phone first. A number without its area code creates a second customer record.
  • A URL that travels. The token in the URL is the only credential, and anyone who has it can create records. Keep it inside Make and out of shared documents and screenshots.
  • A leaked token. Deactivate the integration: requests to an inactive integration are rejected with a 401. Then create a new one with a fresh URL.

Reviewing a Make scenario: three numbers

Judge each scenario on three numbers you can read in StoreChart:

  • Records created: how many records it created this month.
  • Rejected requests: how many requests were rejected, and why.
  • Work saved: how much manual entry it replaced.

What to do with the result:

  • Few records, many failures: a CSV upload may be simpler.
  • Most of your leads: give it an owner who checks the logs weekly.
  • Documentation: note next to each scenario who built it, which app it starts from and which URL it posts to. Whoever takes over then knows what must not be switched off.

For the full field list, see the Make.com integration page and the webhook glossary entry.

Frequently asked questions

Can StoreChart send its own events to Make?

No. StoreChart only receives webhooks. A scenario has to begin in another app, such as a form tool, a marketplace or Google Sheets, and end by posting the data to a StoreChart webhook URL.

What can a Make scenario create in StoreChart?

Three things: an order (custom webhook), a lead (lead webhook), or an order credited to a sales channel such as an ambassador or distributor (channel webhook). A webhook cannot edit an existing order, stock level or price.

What happens if the same order is sent twice?

StoreChart checks the order id against existing orders in that store. A repeat returns the existing order number instead of creating a second copy, so retries from Make are safe as long as the id stays the same.

Do orders sent from Make run my WhatsApp automations?

Yes. StoreChart records the event when the order or lead is saved, whatever the source, so an "order created" or "lead created" rule runs for a webhook record exactly as it does for a WooCommerce order.

See StoreChart with your own store data

Open an account, connect your store and see your own numbers.