---
title: "Zapier, Make, and n8n Static IP Addresses"
description: "Zapier, Make, and n8n Cloud publish outbound IPs that every customer shares. What each list contains, why allowlisting it is weak, and how to relay instead."
canonical: https://fixedmark.com/blog/zapier-make-n8n-static-ip
updated: 2026-11-10
source: Fixedmark (https://fixedmark.com), BitMask LLP
---

AI and automation · 11 min read

# Zapier, Make, and n8n Static IP Addresses

Zapier, Make, and n8n Cloud all publish outbound IP addresses, and every list is shared. Zapier's static IP feature uses 32 addresses for all paid accounts, Make lists three per zone, and n8n Cloud lists 206. To get an IP only you send from, set a fixed-IP proxy in the tool's HTTP step where one exists, or have the workflow call a small relay you own that calls the API through a fixed IP.

## What each tool publishes

A partner API that checks IPs asks one question. Which address will your requests come from? Workflow tools run your steps on their own cloud servers, so the honest answer is one of the addresses the tool publishes. All three publish something, but the lists are very different in size and in what they promise.

_Outbound IPs published by Zapier, Make, and n8n Cloud, checked November 2026_

| Tool             | What it publishes                                                           | Addresses     | Who sends from them                          |
| ---------------- | --------------------------------------------------------------------------- | ------------- | -------------------------------------------- |
| Zapier, default  | No fixed range. Steps run on instances in AWS `us-east-1`                   | Not published | Every Zapier account                         |
| Zapier static IP | `44.214.195.64/28` and `18.246.81.208/28`, for supported apps on paid plans | 32            | Every paid account that uses a supported app |
| Make             | Three egress IPs per zone (us1, us2, eu1, eu2, and two Celonis zones)       | 3 per zone    | Every scenario in that zone                  |
| n8n Cloud        | 12 `/28` blocks and 14 single addresses                                     | 206           | Many n8n Cloud instances per address         |

None of the three offers an address reserved for one customer in its public docs.

## Zapier: no range by default, a shared one on paid plans

Zapier's [IP addresses and allowlisting](https://help.zapier.com/hc/en-us/articles/8496216020877) article says Zapier does not operate with a single, static range of IP addresses. It runs in AWS `us-east-1` and starts instances as it needs them. The same article says that allowing every address in `us-east-1` is not a recommended security practice. Every other AWS customer in that region sends from the same address space, which is why [cloud IP ranges are not an allowlist](https://fixedmark.com/blog/cloud-ip-ranges-are-not-an-allowlist).

On Professional, Team, and Enterprise plans, Zapier offers a [static IP feature](https://help.zapier.com/hc/en-us/articles/15406083674509-Use-a-static-IP-address-to-connect-to-Zapier). Traffic from supported apps leaves from two `/28` blocks, `44.214.195.64/28` in `us-east-1` and `18.246.81.208/28` in `us-west-2`. Each block is 16 addresses, so a partner has to allowlist 32 addresses, or both CIDR blocks if its form accepts them.

- It covers a list of apps, not every step. Webhooks by Zapier, API by Zapier, Salesforce, Stripe, Snowflake, SFTP by Zapier, and about 40 others are on it. Code by Zapier is not on the list as of November 2026.
- Free accounts are not routed through it. Zapier says that if you are on the Free plan and add the addresses, your traffic will not be routed through a static IP.
- For an integration you build on the Zapier Platform, the [developer docs](https://docs.zapier.com/platform/build/static-ip) say the static IPs apply only to requests from paid accounts. A test run by a team member on a free account goes out without them.
- Since October 2025, private integrations can turn it on from a toggle in the Platform UI. Published integrations still need a request to Zapier Support.

The two blocks are published on a public help page and apply to every paid account. Zapier's pages do not say they are shared in so many words, but nothing on them ties an address to one customer, so plan as if every paid Zapier account can send from them.

Zapier also suggests a fallback for systems that cannot allow a wide range. Its requests carry `User-Agent: Zapier`, and the help article proposes accepting requests with that header. Treat this as a label, not a control. Any HTTP client can send any `User-Agent` value, so a check on it stops nobody who wants to get in.

### Zapier's own addresses moved in 2026

Static does not mean permanent. Zapier's [notice on SQL database integrations](https://help.zapier.com/hc/en-us/articles/41225364367501) moved MySQL, PostgreSQL, and SQL Server connections from the single address `54.86.9.50` to the two `/28` blocks above. Customers had to add the new blocks before 15 February 2026, when migration began, and the old address stopped working on 15 March 2026. Any vendor list can move like this, so someone has to watch for notices.

## Make: three addresses per zone

Make's [Allow connections to and from Make IP addresses](https://help.make.com/allow-connections-to-and-from-make-ip-addresses) page lists three egress IPs for each zone. Your zone is the host in your Make URL, such as `eu1.make.com` or `us2.make.com`. For example, `eu2.make.com` sends from `34.254.1.9`, `52.31.156.93`, and `52.50.32.186`. Copy current values from Make's page, since third-party copies go stale.

Three addresses look like a tight allowlist, and that is the trap. The list is per zone, not per account. Every scenario that any Make customer runs in `eu2` sends from those same three addresses. A partner who allowlists them has allowlisted every Make user in the zone.

- The page covers outbound traffic only. It says Make uses dynamic ingress IPs, so you cannot pin the address your systems use to reach a Make webhook.
- The page does not describe a dedicated or per-account IP option on any plan, and it gives no notice policy for changes.
- The HTTP app's Make a request module has a Proxy setting under Advanced settings. Per the [HTTP app docs](https://apps.make.com/http), you create a proxy keychain with a host, a port, and an optional username and password. The other HTTP modules, Download a file and Resolve URL, do not list one.

That proxy keychain is the native way out of the shared list for Make. Built-in app modules, such as a CRM or ERP connector, have no proxy field. For those, call the vendor's API from a Make a request module instead.

## n8n Cloud: a list n8n tells you not to trust

n8n is the most direct of the three. Its [Find your n8n Cloud IP addresses](https://docs.n8n.io/deploy/use-n8n-cloud/configure-cloud/find-your-ip-addresses) page lists 12 `/28` blocks and 14 single addresses, 206 addresses in all, and recommends allowlisting all of them. The same page says n8n Cloud runs on shared infrastructure, that no address is unique to your instance, and that an allowlist alone does not prove a request came from your instance.

- Addresses rarely change, but your instance's address can change if n8n moves it to another cluster, and n8n does not give advance notice.
- New addresses may be added to the list over time.
- You can find your instance's current address by calling an IP echo service from an HTTP Request node. n8n warns that allowlisting only that one address can break workflows when it changes.
- Inbound webhook traffic to your n8n instance does not use these addresses.

Self-hosted n8n has no published list at all. It sends from whatever host runs it. That is a fixed address on a VM with a reserved IP, and a changing one on most PaaS platforms and home connections. The HTTP Request node has a Proxy option on both Cloud and self-hosted, and the [n8n integration guide](https://fixedmark.com/integrations/n8n) covers it field by field, including the global `HTTPS_PROXY` variable for self-hosted instances.

## What allowlisting a shared list admits

Think about why the partner asked for your IP. An IP allowlist exists so that a stolen API key is useless from anywhere else. If an attacker copies your key out of a log or a leaked workflow export, the partner still rejects calls from the attacker's address.

A shared list breaks that. Once the partner allowlists Zapier's 32 addresses, a stolen key works from any paid Zapier account. Once it allowlists Make's three `eu2` addresses, it works from any Make account in that zone. Opening one of those accounts takes a sign-up form, plus a paid plan in Zapier's case. The IP check still runs, but it no longer separates you from anyone else on the tool.

- The partner's security review may reject it. Banks, payout APIs, and enterprise IT teams often ask whether an address is used only by you. For a shared list the true answer is no. Indian banks in particular expect production IPs that belong to the integrating company, as covered in [bank API onboarding and IP whitelisting](https://fixedmark.com/blog/bank-api-onboarding-ip-whitelisting-india).
- You inherit the vendor's change schedule. When Zapier moved its SQL address, or when n8n moves an instance to another cluster, every allowlist that names the old address breaks until someone updates it.
- Your allowlist entries describe the tool, not your company. If you later move the workflow from Make to n8n, every partner has to update its list again.

A shared list is still fine when the system on the other end is yours and the IP check is a coarse first filter, for example a staging database that also requires a strong password and TLS. It is the wrong answer when a partner asks for your IP and means it.

## Three ways to get an address that is only yours

_Options for a dedicated outbound IP, by workflow tool_

| Option                                  | Zapier                                    | Make                                              | n8n                                                     |
| --------------------------------------- | ----------------------------------------- | ------------------------------------------------- | ------------------------------------------------------- |
| Proxy setting on the HTTP step          | Not documented for Webhooks or Code steps | Make a request, Advanced settings, Proxy keychain | HTTP Request node, Options, Proxy                       |
| Relay you own, called from the workflow | Webhooks by Zapier to your relay          | Make a request to your relay                      | HTTP Request node to your relay                         |
| Run the tool on your own host           | Not possible                              | Not possible                                      | Self-host on a VM with a reserved IP, or behind a proxy |

A proxy setting is the least work where it exists. The workflow still talks to the partner directly, only the TCP connection now leaves from the proxy's address. TLS runs end to end between the tool and the partner, so a CONNECT proxy sees the hostname and byte counts but not the request. The mechanics are in [how an HTTP CONNECT proxy works](https://fixedmark.com/blog/http-connect-proxy-explained).

A relay is the option that works everywhere, including Zapier and built-in app steps that have no proxy field. The workflow calls a small HTTPS endpoint you run. The endpoint calls the partner through a fixed IP and returns the response. It also moves the partner's API key out of the workflow tool and into your own secret store, which is often what a partner's security team wanted in the first place.

## Build a relay the workflow calls

Keep the relay narrow. It should call one partner host, for one or two operations, with inputs it checks itself. A relay that takes any URL from the request body is an open proxy on your trusted IP, and anyone who finds its secret can use your allowlist entry for anything.

- Authenticate the workflow with a long random secret in a header, compared in constant time. Use a different secret per workflow tool so you can revoke one.
- Fix the destination in code. The workflow sends data fields, never a URL or a host.
- Validate every field. Workflow tools often send numbers as strings, so parse them on purpose.
- Set a timeout shorter than the workflow step's own limit, so the step gets a clear error instead of hanging.
- Pass an idempotency key on writes if the partner API supports one. Workflow tools can retry a failed step, and a retry should not create a second order or payout.
- Read the proxy URL from a variable no library picks up on its own, such as `EGRESS_PROXY_URL`, and pass it to one client. The reasons are in [HTTPS_PROXY, NO_PROXY, and per-client agents](https://fixedmark.com/blog/selective-proxying-no-proxy-and-per-client-agents).

**Next.js route handler (undici)**

```typescript
// app/api/relay/orders/route.ts
// npm install undici
import { timingSafeEqual } from "node:crypto";
import { fetch, ProxyAgent } from "undici";

const PARTNER_URL = "https://api.partner.example/v1/orders";

// One agent for the whole process, so connections are reused.
const fixedIp = new ProxyAgent(process.env.EGRESS_PROXY_URL!);

function secretMatches(sent: string | null): boolean {
  const want = Buffer.from(process.env.RELAY_SECRET!);
  const got = Buffer.from(sent ?? "");
  return got.length === want.length && timingSafeEqual(got, want);
}

export async function POST(request: Request): Promise<Response> {
  if (!secretMatches(request.headers.get("x-relay-secret"))) {
    return new Response("unauthorized", { status: 401 });
  }

  const input = (await request.json().catch(() => null)) as {
    sku?: unknown;
    quantity?: unknown;
    idempotency_key?: unknown;
  } | null;
  const sku = input?.sku;
  const quantity = Number(input?.quantity); // workflow tools often send "3"
  const key = input?.idempotency_key;
  if (
    typeof sku !== "string" ||
    !/^[A-Z0-9-]{1,32}$/.test(sku) ||
    !Number.isInteger(quantity) ||
    quantity < 1 ||
    quantity > 1000 ||
    typeof key !== "string" ||
    key.length === 0 ||
    key.length > 64
  ) {
    return new Response("bad request", { status: 400 });
  }

  const res = await fetch(PARTNER_URL, {
    method: "POST",
    dispatcher: fixedIp,
    headers: {
      authorization: `Bearer ${process.env.PARTNER_API_KEY}`,
      "content-type": "application/json",
      "idempotency-key": key,
    },
    body: JSON.stringify({ sku, quantity }),
    signal: AbortSignal.timeout(20_000),
  });

  // A 204 or 304 response must not carry a body, even an empty string.
  const body = res.status === 204 || res.status === 304 ? null : await res.text();
  return new Response(body, {
    status: res.status,
    headers: {
      "content-type": res.headers.get("content-type") ?? "application/json",
    },
  });
}
```

**Python (Flask and requests)**

```python
# pip install flask "requests>=2.32"
import hmac
import os
import re

import requests
from flask import Flask, abort, request

app = Flask(__name__)

PARTNER_URL = "https://api.partner.example/v1/orders"
RELAY_SECRET = os.environ["RELAY_SECRET"].encode()
PROXY = os.environ["EGRESS_PROXY_URL"]

# One session for the whole process, so connections are reused.
partner = requests.Session()
partner.trust_env = False  # ignore HTTPS_PROXY and NO_PROXY from the env
partner.proxies = {"http": PROXY, "https": PROXY}
partner.headers["Authorization"] = f"Bearer {os.environ['PARTNER_API_KEY']}"

@app.post("/relay/orders")
def create_order():
    sent = request.headers.get("X-Relay-Secret", "").encode()
    if not hmac.compare_digest(sent, RELAY_SECRET):
        abort(401)

    data = request.get_json(silent=True)
    if not isinstance(data, dict):
        abort(400)
    sku = data.get("sku")
    key = data.get("idempotency_key")
    try:
        quantity = int(str(data.get("quantity")))  # workflow tools often send "3"
    except ValueError:
        abort(400)
    if (
        not isinstance(sku, str)
        or not re.fullmatch(r"[A-Z0-9-]{1,32}", sku)
        or not 1 <= quantity <= 1000
        or not isinstance(key, str)
        or not 0 < len(key) <= 64
    ):
        abort(400)

    res = partner.post(
        PARTNER_URL,
        json={"sku": sku, "quantity": quantity},
        headers={"Idempotency-Key": key},
        timeout=(5, 20),
    )
    content_type = res.headers.get("Content-Type", "application/json")
    return res.content, res.status_code, {"Content-Type": content_type}
```

Host the relay anywhere that can make outbound calls through a proxy, such as a Vercel or Railway app, a Lambda function, or a small VM. If it runs on a VM with a reserved IP, you can skip the proxy and allowlist the VM itself. Cloudflare Workers cannot use a normal CONNECT proxy from `fetch`, as [edge runtimes and outbound proxies](https://fixedmark.com/blog/edge-runtimes-and-outbound-proxies) explains, so pick a Node or Python runtime for this.

On the workflow side, the step that used to call the partner now calls the relay. The partner's key no longer lives in the workflow.

**Workflow step settings**

```
Zapier: Webhooks by Zapier, POST action
  URL:          https://relay.example.com/api/relay/orders
  Payload Type: json
  Data:         sku = <mapped field>
                quantity = <mapped field>
                idempotency_key = <a field unique to this record>
  Headers:      X-Relay-Secret = <your Zapier relay secret>

Make: HTTP, Make a request
  URL:     https://relay.example.com/api/relay/orders
  Method:  POST
  Headers: X-Relay-Secret = <your Make relay secret>
  Body:    JSON with sku, quantity, idempotency_key

n8n: HTTP Request node
  Method:  POST
  URL:     https://relay.example.com/api/relay/orders
  Headers: X-Relay-Secret = <your n8n relay secret>
  Body:    JSON with sku, quantity, idempotency_key
```

Make accepts only HTTPS URLs with verified certificates in Make a request. Give the relay a real certificate, which every PaaS above does by default. A self-signed certificate is rejected.

## Doing this with Fixedmark

Fixedmark gives an app a pair of static outbound IPv4 addresses in Mumbai, Singapore, Newark, or Ashburn, reached through one proxy URL such as `https://APP_ID:TOKEN@mum.egress.fixedmark.com:443`. It is in early access and not generally available yet. A dedicated pair comes with the Pro plan at a planned $29 a month. The 7-day trial and the Starter plan run on a shared pair, which is the same problem this post describes, so do not register those addresses with a partner. See [pricing](https://fixedmark.com/pricing).

- n8n. Paste the proxy URL into the HTTP Request node's Proxy option. The [n8n guide](https://fixedmark.com/integrations/n8n) has the node JSON and the self-hosted setup.
- Relay. Set `EGRESS_PROXY_URL` to the `https://` proxy URL. The [Node.js](https://fixedmark.com/docs/node) and [Python](https://fixedmark.com/docs/python) docs list the client versions that open TLS to the proxy.
- Make. The proxy keychain takes a host and port, not a URL with a scheme, and Make's docs do not say whether it opens TLS to the proxy. Plan on the plain HTTP proxy, host `mum.egress.fixedmark.com`, port `8080`, with `APP_ID` as the username and `TOKEN` as the password. That port sends the token in cleartext on the way from Make to the proxy. Your request to the partner stays inside its own TLS session.
- Zapier. Use the relay. Zapier's docs describe no proxy setting for Webhooks by Zapier or Code by Zapier.

Give each tool its own credential. For a token that crosses the network in cleartext, add a [destination allowlist](https://fixedmark.com/docs/allowlists) so it can reach only the partner's host and port, such as `api.partner.example:443`. Allowlists come with the Business plan (planned $79 a month) and up. [Connection logs](https://fixedmark.com/docs/logs) record the destination, SNI, bytes, egress IP, and result for each connection, without decrypting TLS.

Before you send the addresses to the partner, check them from the runtime that will make the call. In n8n or Make, point the HTTP step at `https://fixedmark.com/api/ip` with the proxy set. For a relay, run this from the relay's host.

**Terminal**

```bash
# Through the proxy. Run it a few times. You should see only the two IPs of your pair.
curl -sS --proxy "$EGRESS_PROXY_URL" https://fixedmark.com/api/ip

# Direct, for comparison. This is the host's own address.
curl -sS https://fixedmark.com/api/ip
```

Send the partner both addresses, since each new connection can leave from either one. [Static IP pairs and failover](https://fixedmark.com/blog/static-ip-pairs-and-failover) explains why. Pick the region nearest the partner's API, Mumbai for an Indian bank or payout API such as [RazorpayX](https://fixedmark.com/blog/razorpayx-payouts-ip-whitelisting). To try it before launch, [join early access](https://fixedmark.com/early-access).

## Sources

Checked November 2026. Confirm current details on the vendor's site before you decide. Prices and limits change.

- [Zapier: IP addresses and allowlisting](https://help.zapier.com/hc/en-us/articles/8496216020877)
- [Zapier: Use a static IP address to connect to Zapier](https://help.zapier.com/hc/en-us/articles/15406083674509-Use-a-static-IP-address-to-connect-to-Zapier)
- [Zapier Platform: Static IP](https://docs.zapier.com/platform/build/static-ip)
- [Zapier Platform: Static IP self-serve for private integrations](https://docs.zapier.com/integrations/news/2025/static-ip-self-serve.md)
- [Zapier: New static IP addresses for SQL database integrations](https://help.zapier.com/hc/en-us/articles/41225364367501)
- [Make: Allow connections to and from Make IP addresses](https://help.make.com/allow-connections-to-and-from-make-ip-addresses)
- [Make: HTTP app](https://apps.make.com/http)
- [n8n docs: Find your n8n Cloud IP addresses](https://docs.n8n.io/deploy/use-n8n-cloud/configure-cloud/find-your-ip-addresses)
- [n8n docs: HTTP Request node](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/)

Keep reading

## Related guides

- [Integration n8n Fixed IPs for n8n HTTP Request nodes on n8n Cloud or self-hosted.](https://fixedmark.com/integrations/n8n)
- [Use case AI agents and automations Give n8n workflows, Lovable apps, and AI agent tool calls a fixed IP that allowlisted APIs accept.](https://fixedmark.com/use-cases/ai-agents-and-automations)
- [Use case Partner API allowlisting Give Salesforce, SOAP vendors, and payment gateways one dedicated IP pair to allowlist, wherever your code runs.](https://fixedmark.com/use-cases/partner-api-allowlisting)
- [Comparison QuotaGuard alternative QuotaGuard Static and Shield published plans next to Fixedmark's planned $29 dedicated pair.](https://fixedmark.com/compare/quotaguard-alternative)
- [Guide Pricing Planned launch plans, from a shared pair to a dedicated IP pair.](https://fixedmark.com/pricing)

## Frequently asked questions

### Does Zapier have a static IP?

On Professional, Team, and Enterprise plans, supported apps such as Webhooks by Zapier send from 44.214.195.64/28 and 18.246.81.208/28. Those 32 addresses apply to every paid account, so they identify Zapier, not you. Free accounts are not routed through them.

### Can I get a dedicated IP for my Make scenarios?

Make's help center lists three shared egress IPs per zone and describes no per-account option. Set a proxy keychain in the HTTP Make a request module, or call a relay you own that sends the request from a fixed IP.

### Is it safe to allowlist n8n Cloud's IP addresses?

Only as a coarse filter on a system that also requires strong authentication. n8n's own docs say the addresses are shared, none is unique to your instance, and your instance's address can change without notice.

### Is checking for User-Agent: Zapier a safe alternative to an IP allowlist?

No. Any HTTP client can send that header. It tells you a request claims to be from Zapier, not that it is, and it says nothing about which Zapier account sent it.

### Why use a relay instead of putting the partner's API key in the workflow?

The relay gives the call a fixed IP, and it keeps the partner's key in your own secret store. Anyone who can edit or export the workflow sees only the relay secret, which you can rotate without asking the partner for anything.
