Home / Blog / Amazon Product Data in Make.com: HTTP Module, No Code

Amazon Product Data in Make.com: HTTP Module, No Code

Pull Amazon product data into Make.com (formerly Integromat) with the built-in HTTP module: a Schedule trigger, one call to /amazon-product-offers per ASIN, a Data store that holds the last known price, and a Router branch on a Buy Box price drop. Covers the one HTTP module setting that decides whether a billed error ever reaches an error handler at all.

November 18, 2026
7 min read
SellerMagnet Team
Share & Bookmark
Terminal window running a Make.com scenario that reports an Amazon Buy Box price drop

Make.com (the automation platform formerly called Integromat) reaches the SellerMagnet API with its built-in HTTP module, no custom backend and no self-hosted instance to run. A Schedule trigger fires the scenario on an interval, the HTTP module calls /amazon-product-offers once per tracked ASIN, a Data store module reads the last known price for that ASIN, a Router splits the run into a drop branch and a no-drop branch, and a second Data store module writes the new baseline back. The scenario below is a real blueprint (Make's export/import format), and the comparison logic inside its Router filters is ported to Python and run standalone further down, the same way the logic behind every webhook or Code node in this series is proven before it ships.

Key Takeaways

  • The HTTP module sends X-Api-Key as a header, built from a Make connection, never pasted into the URL.
  • Return error if HTTP request fails must be Yes, or a 4xx/5xx response (a billed 404, a free 429) passes through as an ordinary successful bundle and no error route, Router branch or error handler ever sees it, the opposite default problem from n8n's HTTP Request node (which needs Never Error ON to avoid stopping; Make's HTTP module needs this setting ON to avoid silently swallowing the error).
  • State lives in a Make Data store, read with Get a record and written with Update a record (Insert missing record on), keyed by ASIN; it is not a scenario variable (util:SetVariable2 only lasts for one execution) and not a spreadsheet row looked up by formula.
  • The HTTP module's own timeout defaults to 40 seconds and only goes up to 300; SellerMagnet's documented scrape allowance is up to about 120 seconds, so the module's Timeout field has to be raised past the default before a slow lookup is mistaken for a failure.
  • Make's own Retry error handler does not know which SellerMagnet status codes are billed; a Router filter on the HTTP module's status code, not a blanket Retry, decides whether to resend a call (free 429/401/403/gate-400; a bare 500 without a Retry-After header is refunded every time, no counter or time limit) or leave it alone (billed 404, exhausted 502/503).

How does Make.com authenticate to the API?

Add the HTTP module, Make a request, and under Headers add one entry: name X-Api-Key, value the SellerMagnet API key. Make stores module parameters in plain text inside an exported blueprint, so the recommended setup wraps the key in a keychain-backed HTTP connection (Add, create a connection) instead of typing it directly into the Headers field; the connection's stored value never appears in a shared or exported blueprint, only a reference to the connection by name does.

The scenario, exported as a blueprint

Six modules: Schedule, HTTP (Make a request), Data store (Get a record), Router, Data store (Update a record) on the drop branch, and a webhook/email/Slack module on the same branch. Import this JSON (Scenario menu, Import Blueprint), attach an HTTP connection carrying the API key header, point the Data store modules at your own store, and it runs as is.

The scenario blueprint, Make's own export/import format for a 6-module scenario

{
  "name": "Amazon Buy Box price watch (SellerMagnet)",
  "flow": [
    {
      "id": 1,
      "module": "util:Scheduler",
      "version": 1,
      "parameters": {},
      "mapper": {
        "type": "interval",
        "interval": 360
      },
      "metadata": {
        "designer": {"x": 0, "y": 0},
        "restore": {}
      }
    },
    {
      "id": 2,
      "module": "http:ActionSendData",
      "version": 3,
      "parameters": {
        "handleErrors": true,
        "useNewZLibDeCompress": true
      },
      "mapper": {
        "url": "https://sellermagnet-api.com/api/amazon-product-offers",
        "method": "get",
        "headers": [
          {"name": "X-Api-Key", "value": "{{connection.apiKey}}"}
        ],
        "qs": [
          {"name": "asin", "value": "{{1.asin}}"},
          {"name": "marketplaceId", "value": "ATVPDKIKX0DER"}
        ],
        "timeout": "120",
        "bodyType": "raw",
        "parseResponse": true,
        "followRedirect": true,
        "rejectUnauthorized": true
      },
      "metadata": {
        "designer": {"x": 300, "y": 0},
        "restore": {
          "expect": {
            "handleErrors": {"label": "Return error if HTTP request fails: Yes"}
          }
        }
      }
    },
    {
      "id": 3,
      "module": "datastore:ActionGet",
      "version": 1,
      "parameters": {
        "datastore": 100001
      },
      "mapper": {
        "key": "{{1.asin}}"
      },
      "metadata": {
        "designer": {"x": 600, "y": 0}
      }
    },
    {
      "id": 4,
      "module": "builtin:BasicRouter",
      "version": 1,
      "mapper": null,
      "metadata": {
        "designer": {"x": 900, "y": 0}
      },
      "routes": [
        {
          "flow": [
            {
              "id": 5,
              "module": "datastore:ActionAddUpdate",
              "version": 1,
              "parameters": {
                "datastore": 100001
              },
              "mapper": {
                "key": "{{1.asin}}",
                "baseline": "{{round(2.data.buyBox.totalPrice; 2)}}"
              },
              "metadata": {
                "designer": {"x": 1200, "y": -80}
              },
              "filter": {
                "name": "Price dropped",
                "conditions": [
                  [
                    {"a": "{{2.data.success}}", "o": "text:equal", "b": "true"},
                    {"a": "{{2.data.buyBox}}", "o": "exist"},
                    {"a": "{{3.data.baseline}}", "o": "exist"},
                    {"a": "{{round(2.data.buyBox.totalPrice; 2)}}", "o": "number:less", "b": "{{round(ifempty(3.data.baseline; 999999999); 2)}}"}
                  ]
                ]
              }
            },
            {
              "id": 6,
              "module": "gateway:CustomWebHook",
              "version": 1,
              "parameters": {},
              "mapper": {
                "hook": 200001,
                "data": "{\"asin\": \"{{1.asin}}\", \"newPrice\": {{round(2.data.buyBox.totalPrice; 2)}}, \"previousPrice\": {{3.data.baseline}}}"
              },
              "metadata": {
                "designer": {"x": 1500, "y": -80}
              }
            }
          ]
        },
        {
          "flow": [
            {
              "id": 7,
              "module": "datastore:ActionAddUpdate",
              "version": 1,
              "parameters": {
                "datastore": 100001
              },
              "mapper": {
                "key": "{{1.asin}}",
                "baseline": "{{round(2.data.buyBox.totalPrice; 2)}}"
              },
              "metadata": {
                "designer": {"x": 1200, "y": 80}
              },
              "filter": {
                "name": "No drop (default route)",
                "conditions": []
              }
            }
          ]
        }
      ]
    }
  ],
  "metadata": {
    "instant": false,
    "version": 1,
    "scenario": {
      "roundtrips": 1,
      "maxErrors": 3,
      "autoCommit": true,
      "autoCommitTriggerLast": true,
      "sequential": false,
      "confidential": false,
      "dataloss": false,
      "dlq": false,
      "freshVariables": false
    },
    "designer": {
      "orphans": []
    },
    "zone": "eu1.make.com"
  }
}

Why does the HTTP module need Return error if HTTP request fails set to Yes?

By default Make's HTTP module treats any response, including a 4xx or 5xx one, as a normal bundle: the module output just contains a statusCode field and the body, and the scenario keeps running as if the call had succeeded. Turning Return error if HTTP request fails to Yes is what makes Make raise an actual error on a 4xx/5xx response, which is the only way an error handler route (Ignore/Skip, Break/Retry, Commit, Resume, Rollback, depending on which UI version is showing) or a downstream Router filter on the error ever fires at all. Left off, a billed 404 on a delisted ASIN looks exactly like a successful lookup to the rest of the scenario.

The six modules in the scenario and what each one costs.
ModuleDoesCost
ScheduleFires the scenario on an intervalfree
HTTP - Make a requestCalls /amazon-product-offers, one call per ASIN1 credit per ASIN
Data store - Get a recordReads the stored baseline for that ASINfree
RouterSplits into a drop branch and a no-drop branchfree
Data store - Update a recordWrites the new baseline, insert if missingfree
Webhooks / Email / SlackRuns on the drop branch onlyfree

How do I compare today's price with yesterday's?

With a Data store: Get a record (keyed by ASIN) before the Router, Update a record (Insert missing record on, so the very first run creates the row instead of erroring) after it. A Make Data store record survives between scenario runs on its own, no scenario variable or extra app needed; the Router's two filters read the HTTP module's data.buyBox.totalPrice field against the Data store module's baseline field directly as Make formulas, rounded to avoid floating-point noise from an unrounded landed price (item + shipping) comparing unequal to an already-rounded stored baseline.

The two Router filter conditions, written as Make formulas (no code module needed for this scenario)

Route 1, "Price dropped":
  {{2.data.success}} = true
  AND {{2.data.buyBox}} is not empty
  AND {{3.data.baseline}} is not empty
  AND round(2.data.buyBox.totalPrice; 2) < round(ifempty(3.data.baseline; 999999999); 2)

Route 2, "No drop (default)":
  (none; this is the Router's fallback route, taken whenever Route 1's filter does not match,
  including a delisted ASIN's billed 404, a "N/A" Buy Box with no featured offer, or no
  stored baseline yet, i.e. this ASIN's very first cycle)

The same decision, ported to Python and run standalone before it went into the two Router filters above, to prove the logic once outside the scenario builder's own test-run UI.

Router filter logic ported to Python and run standalone on 5 cases (illustrative data, matches the scenario run below)

"""Logic behind the two Router filters, tested standalone before it went into the scenario."""


def compare(api_ok, buy_box, baseline):
    # buy_box is data.buyBox from /amazon-product-offers: {} (falsy-looking,
    # still truthy in Python/JS) when nobody holds the Buy Box right now.
    price = None
    if api_ok:
        raw = buy_box.get("totalPrice") if buy_box else None
        price = round(raw, 2) if isinstance(raw, (int, float)) else None
    dropped = api_ok and price is not None and baseline is not None and price < baseline
    new_baseline = price if price is not None else baseline
    return {"priceDropped": dropped, "newBaseline": new_baseline}


if __name__ == "__main__":
    print("cycle 1, B0BASE001, no stored baseline yet:", compare(True, {"totalPrice": 444.99}, baseline=None))
    print("cycle 2, B0DROP001, real price drop:", compare(True, {"totalPrice": 419.99}, baseline=444.99))
    print("cycle 2, B0NOISE001, float-noise price, rounds to the stored baseline:",
          compare(True, {"totalPrice": 15.02 + 3.99}, baseline=19.01))
    print("cycle 1/2, B0NOBB001, nobody holds the Buy Box:", compare(True, {}, baseline=None))
    print("cycle 1/2, B0GONE001, delisted ASIN, billed 404, success:false:", compare(False, None, baseline=None))

Python port output

cycle 1, B0BASE001, no stored baseline yet: {'priceDropped': False, 'newBaseline': 444.99}
cycle 2, B0DROP001, real price drop: {'priceDropped': True, 'newBaseline': 419.99}
cycle 2, B0NOISE001, float-noise price, rounds to the stored baseline: {'priceDropped': False, 'newBaseline': 19.01}
cycle 1/2, B0NOBB001, nobody holds the Buy Box: {'priceDropped': False, 'newBaseline': None}
cycle 1/2, B0GONE001, delisted ASIN, billed 404, success:false: {'priceDropped': False, 'newBaseline': None}
Blueprint table of the six Make.com modules in the scenario and their cost
Only the HTTP module spends credits.

A free plan cannot schedule tighter than 15 minutes

The Schedule module's minimum interval depends on the Make plan: the Free plan's floor is 15 minutes between runs; paid Core/Pro/Teams plans allow down to 1 minute. Below the plan's floor the Schedule settings panel will not accept the value, not a billing-side rejection from SellerMagnet.

What happens on a rate limit or a server error?

Make's own Retry error handler resends a failed module up to a set number of attempts (3 by default, 15 minutes apart) and, with Store incomplete executions on, Make automatically retries a ConnectionError (502/503/504), a RateLimitError (429) or a ModuleTimeoutError without a Retry handler at all. None of that is billing-aware: it does not know that SellerMagnet already refunds a bare 500 once, or that a 404 stays billed on every attempt. A Router filter checking the HTTP module's own status code, placed before any retry decision, keeps the scenario from blindly resending a billed 404 or stopping on a free 429 that only needed to wait out its Retry-After header; the 5xx retry logic reference has the full billing table this scenario follows.

How often should the schedule run?

Each cycle is one HTTP module call per tracked ASIN; every six hours costs about 120 credits per ASIN a month and catches any Buy Box change within six hours, daily checks cost 30. The Buy Box polling interval guide has the full interval-versus-cost table for a single account watching many ASINs, and the n8n build shows the identical Schedule, call, compare, alert shape on a self-hosted automation tool instead of a cloud-only one.

Blueprint bar chart of credits per tracked ASIN per month for four schedule intervals
Credits per tracked ASIN per month by schedule interval.

Frequently Asked Questions

Do I need to write any code to use the SellerMagnet API in Make.com?

None. The HTTP module calls the API directly, the Router's filters are built from Make's own formula fields, not a scripting language, and the Data store modules need no query language.

Where does the API key go?

Into an HTTP connection's stored header, created once and attached to the HTTP module; never typed into the URL or the module's visible parameters if the blueprint is ever shared.

What happens when the cycle checks a delisted ASIN?

With Return error if HTTP request fails set to Yes, the billed 404 raises an error on the HTTP module; a Router filter or error handler route can read the status code and skip that ASIN instead of stopping the whole cycle.

Why a Data store instead of a scenario variable or a spreadsheet?

A util:SetVariable2 variable only lasts for the one execution that set it; nothing it writes is there on the next cycle. A Data store record, read by key, survives between cycles on its own, no extra app connection needed.

Can I post the alert to Slack instead of a generic webhook?

Yes, swap the final module on the drop branch for a Slack action; the Data store read, Router filter and Data store write before it do not change.

Bottom line: one HTTP module, one connection carrying the API key, a Data store for state and a Router with two formula filters turn Make.com into an Amazon price and Buy Box watcher with zero custom backend and zero self-hosted infrastructure, provided the one easy-to-miss HTTP module setting, Return error if HTTP request fails, is switched on first. Every field the module reads is on the product offers page.

Ready to Extract Amazon Data at Scale?

Start building with SellerMagnet API today. Real-time product data, competitive pricing, and review analytics at your fingertips.

150 free API credits • No credit card required • Cancel anytime