<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>HTTP 429 | John Nessime</title>
	<atom:link href="https://john-nessime.com/blog/tag/http-429/feed/" rel="self" type="application/rss+xml" />
	<link>https://john-nessime.com/blog/tag/http-429/</link>
	<description>Cloud, DevOps, Data &#38; AI — Built, Tested, Explained</description>
	<lastBuildDate>Mon, 02 Nov 2026 07:03:28 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.4</generator>

<image>
	<url>https://john-nessime.com/blog/wp-content/uploads/2026/07/cropped-jn-32x32.png</url>
	<title>HTTP 429 | John Nessime</title>
	<link>https://john-nessime.com/blog/tag/http-429/</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>AWS WAF Rate-Based Rules: Stop the Flood, Not Your Best Customer</title>
		<link>https://john-nessime.com/blog/devops/aws-waf-rate-based-rules/</link>
		
		<dc:creator><![CDATA[John Nessime]]></dc:creator>
		<pubDate>Mon, 02 Nov 2026 07:03:28 +0000</pubDate>
				<category><![CDATA[Cloud Security]]></category>
		<category><![CDATA[DevOps]]></category>
		<category><![CDATA[Web Security]]></category>
		<category><![CDATA[Amazon CloudFront]]></category>
		<category><![CDATA[API Gateway]]></category>
		<category><![CDATA[Application Load Balancer]]></category>
		<category><![CDATA[AWS]]></category>
		<category><![CDATA[AWS CLI]]></category>
		<category><![CDATA[AWS WAF]]></category>
		<category><![CDATA[Bot Mitigation]]></category>
		<category><![CDATA[Brute Force Protection]]></category>
		<category><![CDATA[CloudWatch]]></category>
		<category><![CDATA[DDoS Protection]]></category>
		<category><![CDATA[HTTP 429]]></category>
		<category><![CDATA[Rate Limiting]]></category>
		<category><![CDATA[Throttling]]></category>
		<category><![CDATA[Web Application Firewall]]></category>
		<category><![CDATA[X-Forwarded-For]]></category>
		<guid isPermaLink="false">https://john-nessime.com/blog/?p=1023</guid>

					<description><![CDATA[<p>Your rate limit worked, and it also blocked your biggest customer's office NAT. How to pick aggregation keys, scope rules per endpoint, return 429 instead of 403, and roll out AWS WAF rate-based rules in Count mode first.</p>
<p>The post <a href="https://john-nessime.com/blog/devops/aws-waf-rate-based-rules/">AWS WAF Rate-Based Rules: Stop the Flood, Not Your Best Customer</a> appeared first on <a href="https://john-nessime.com/blog">John Nessime</a>.</p>
]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">The ticket usually reads something like this: <em>&#8220;Your API started returning 403 to our integration around nine this morning. Nothing changed on our side.&#8221;</em> You check the application logs and there&#8217;s nothing there, because the requests never reached the application. They died at the edge, in a WAF rule somebody added last month to stop a credential-stuffing run on the login page.</p>



<p class="wp-block-paragraph">That rule worked. It also counted every request from the customer&#8217;s office NAT, their ERP connector and their warehouse scanners as one source, and at the start of the working day that one source crossed the line. The customer who sends you the most traffic is, almost by definition, the one most likely to look like an attacker to a counter that only sees IP addresses.</p>



<p class="wp-block-paragraph">This post is about building <strong>AWS WAF rate-based rules</strong> that catch floods, scrapers and brute-force attempts without throttling the people you actually want. I&#8217;ll go through the four ways these rules go wrong (the key, the scope, the response and the timing), a rollout order that keeps you out of trouble, and the troubleshooting steps for when a real user gets caught anyway.</p>



<h2 class="wp-block-heading">How AWS WAF rate-based rules actually count</h2>



<p class="wp-block-paragraph">A rate-based rule does three things. It decides which requests it cares about (the scope-down statement), it groups those requests into buckets (the aggregation key), and it counts each bucket over a sliding look-back window. When a bucket goes over your limit, the rule action applies to requests in that bucket until the rate falls back under.</p>



<p class="wp-block-paragraph">By default the bucket is the source IP address, and the window is five minutes. You can change both. AWS lets you pick a one, two, five or ten minute evaluation window, and you can aggregate on things other than IP: a forwarded IP header, a header value, a cookie, a query argument, the URI path, the HTTP method, an ASN, a JA3 or JA4 TLS fingerprint, or a label namespace set by an earlier rule. You can combine several of these into a composite key.</p>



<p class="wp-block-paragraph">Most bad outcomes come from one of those choices being made with the attacker&#8217;s traffic in mind and never checked against the customer&#8217;s.</p>



<h2 class="wp-block-heading">Failure family 1: the key groups the wrong people together</h2>



<h3 class="wp-block-heading">Shared egress IPs look like one very busy client</h3>



<p class="wp-block-paragraph">IP aggregation assumes one IP is roughly one client. That stopped being true a long time ago. A company office sits behind one NAT address. Mobile carriers put thousands of subscribers behind carrier-grade NAT. People browsing through a commercial VPN such as NordVPN or Surfshark share exit nodes with strangers. A B2B customer&#8217;s integration server, their staff browsers and their scheduled exports can all arrive from the same address.</p>



<p class="wp-block-paragraph">None of that is abuse, and it all lands in one bucket. A limit sized for &#8220;one heavy user&#8221; is really a limit on everyone behind that address, combined.</p>



<h3 class="wp-block-heading">The proxy in front of WAF hides the client entirely</h3>



<p class="wp-block-paragraph">This one is invisible until it isn&#8217;t. If your web ACL sits on an Application Load Balancer and CloudFront (or another CDN like Cloudflare) sits in front of that load balancer, the source IP that WAF sees on the ALB is the CDN&#8217;s edge address, not the visitor&#8217;s. A plain IP-aggregated rule is now counting &#8220;requests from this CloudFront edge location&#8221;. Under normal load that stays under the limit, so testing looks fine. Under a traffic spike, legitimate users sharing a busy edge get blocked together.</p>



<p class="wp-block-paragraph">There are two fixes, and they aren&#8217;t equal. The cleaner one is to attach the rate-based rule to a web ACL on the CloudFront distribution itself, where the source IP is the viewer. The other is forwarded IP aggregation on the ALB, which reads the client address from a header such as <code>X-Forwarded-For</code>. That brings its own problem.</p>



<h3 class="wp-block-heading">Forwarded IP aggregation trusts the part the client wrote</h3>



<p class="wp-block-paragraph">For rate-based rules, AWS WAF uses the <strong>first</strong> address in the forwarded header. Proxies append to <code>X-Forwarded-For</code>, so the first entry is whatever the client sent before any proxy touched the request. A client that sets its own <code>X-Forwarded-For</code> value, and rotates it on every request, lands in a new bucket every time. Your rate limit never fires for that client, while it keeps working perfectly for honest users who don&#8217;t forge headers.</p>



<p class="wp-block-paragraph">Two related details from the forwarded IP documentation matter here. If the header is missing, the rule doesn&#8217;t apply to that request at all, not even the fallback behavior. And the fallback (match or no match) only kicks in when the header is present but holds a malformed address. So forwarded IP aggregation is safe only when something upstream that you control overwrites the header rather than appending to it. If you can&#8217;t guarantee that, move the rule to the edge.</p>



<h3 class="wp-block-heading">Composite keys exclude requests that lack a component</h3>



<p class="wp-block-paragraph">Custom keys are how you stop punishing shared IPs. Aggregate on an API key header, a session cookie, or IP plus something else, and each customer gets their own bucket. The catch is in one line of the docs: every component in the key must be present, or the request isn&#8217;t evaluated by the rule at all.</p>



<p class="wp-block-paragraph">So a rule keyed on <code>x-api-key</code> rate-limits authenticated clients precisely and ignores anonymous traffic completely. The attacker who simply leaves the header off is invisible to it. You always need a second rule for the requests the first one can&#8217;t see, usually an IP-keyed rule scoped to requests without the header.</p>



<p class="wp-block-paragraph">Here&#8217;s the header-keyed rule. The limit is a placeholder; you&#8217;ll derive a real one from your own logs in a moment.</p>



<pre class="wp-block-code"><code>{
  "Name": "rate-per-api-key",
  "Priority": 20,
  "Statement": {
    "RateBasedStatement": {
      "Limit": 2000,
      "EvaluationWindowSec": 300,
      "AggregateKeyType": "CUSTOM_KEYS",
      "CustomKeys": [
        {
          "Header": {
            "Name": "x-api-key",
            "TextTransformations": [
              {
                "Priority": 0,
                "Type": "NONE"
              }
            ]
          }
        }
      ]
    }
  },
  "Action": {
    "Count": {}
  },
  "VisibilityConfig": {
    "SampledRequestsEnabled": true,
    "CloudWatchMetricsEnabled": true,
    "MetricName": "rate-per-api-key"
  }
}</code></pre>



<p class="wp-block-paragraph">Note the action is <code>Count</code>, not <code>Block</code>. More on why below. Also remember that a header value is only as trustworthy as your API validates it to be. A made-up key still gets its own bucket in WAF, so the backend has to reject it.</p>



<h2 class="wp-block-heading">Failure family 2: one limit for traffic with very different shapes</h2>



<p class="wp-block-paragraph">A single site-wide rule applies one number to everything. But a page load might fetch dozens of assets, an SPA can fire a burst of API calls on first render, and a login form should see a handful of posts per person per session. Any limit loose enough for the first case is useless for the last one.</p>



<p class="wp-block-paragraph">The answer is several narrow rules instead of one wide one, each with a scope-down statement:</p>



<ul class="wp-block-list">

<li><strong>Login, signup, password reset and OTP endpoints:</strong> tight limit, IP or forwarded IP key. This is where credential stuffing and SMS pumping live.</li>


<li><strong>Search, pricing and other expensive endpoints:</strong> moderate limit. Scrapers go here, and each request costs you real backend work.</li>


<li><strong>Authenticated API:</strong> key on the credential, sized from actual per-customer usage.</li>


<li><strong>Everything else:</strong> one generous catch-all on IP, meant for floods, not for shaping.</li>

</ul>



<p class="wp-block-paragraph">Static assets are often best left out of rate counting entirely, especially when a CDN is serving them from cache and they never reach anything expensive. Counting them mainly inflates the numbers for legitimate browsers.</p>



<p class="wp-block-paragraph">A scoped login rule looks like this:</p>



<pre class="wp-block-code"><code>{
  "Name": "rate-login",
  "Priority": 10,
  "Statement": {
    "RateBasedStatement": {
      "Limit": 100,
      "EvaluationWindowSec": 300,
      "AggregateKeyType": "IP",
      "ScopeDownStatement": {
        "ByteMatchStatement": {
          "SearchString": "/login",
          "FieldToMatch": {
            "UriPath": {}
          },
          "TextTransformations": [
            {
              "Priority": 0,
              "Type": "LOWERCASE"
            }
          ],
          "PositionalConstraint": "STARTS_WITH"
        }
      }
    }
  },
  "Action": {
    "Count": {}
  },
  "VisibilityConfig": {
    "SampledRequestsEnabled": true,
    "CloudWatchMetricsEnabled": true,
    "MetricName": "rate-login"
  }
}</code></pre>



<p class="wp-block-paragraph">The <code>LOWERCASE</code> transformation matters more than it looks. Without it, <code>/Login</code> may route to the same handler in your app but fall outside the scope-down match.</p>



<h3 class="wp-block-heading">Exempting a partner: Allow is heavier than it looks</h3>



<p class="wp-block-paragraph">When a known partner keeps tripping a limit, the tempting fix is an IP set rule with an <code>Allow</code> action placed above the rate rule. It works, but <code>Allow</code> is terminating. That partner&#8217;s traffic now skips every rule below it, including your managed rule groups for injection and known bad inputs. If their integration server is ever compromised, you&#8217;ve pre-approved the attacker.</p>



<p class="wp-block-paragraph">The narrower fix is to exclude the IP set inside the rate rule&#8217;s own scope-down, with a <code>NotStatement</code> around an IP set reference, combined with your path match in an <code>AndStatement</code>. The partner is exempt from counting and nothing else.</p>



<h2 class="wp-block-heading">Failure family 3: the response breaks the client instead of slowing it</h2>



<p class="wp-block-paragraph">The default Block action returns a 403. To a well-behaved API client, 403 means &#8220;you&#8217;re not allowed&#8221;, and many clients treat that as permanent: they stop, raise an alert, or worse, retry immediately in a loop that keeps them over the limit.</p>



<p class="wp-block-paragraph">A rate limit should say what it is. AWS WAF supports a custom response on Block, so you can return 429 with a <code>Retry-After</code> header, which HTTP clients and SDKs generally understand as &#8220;back off and try later&#8221;:</p>



<pre class="wp-block-code"><code>{
  "Action": {
    "Block": {
      "CustomResponse": {
        "ResponseCode": 429,
        "ResponseHeaders": [
          {
            "Name": "Retry-After",
            "Value": "60"
          }
        ]
      }
    }
  }
}</code></pre>



<p class="wp-block-paragraph">You can also reference a custom response body defined on the web ACL, such as a small JSON error, so API clients get something parseable.</p>



<p class="wp-block-paragraph">What about Challenge and CAPTCHA? They&#8217;re genuinely useful on human-facing pages, because a real browser passes a silent challenge and a basic script doesn&#8217;t. On API endpoints they&#8217;re a trap. A mobile app, a server-to-server integration or a webhook sender can&#8217;t complete a browser challenge, so for them Challenge behaves like a block with a confusing response. Keep those actions to routes where you know a browser is on the other end.</p>



<h2 class="wp-block-heading">Failure family 4: expecting precision the service doesn&#8217;t promise</h2>



<p class="wp-block-paragraph">AWS is explicit that WAF rate limiting is meant to control high request rates, not to enforce exact quotas. It estimates the rate with an algorithm that weights recent requests more heavily, so it acts <em>near</em> your limit rather than exactly on it. There&#8217;s also lag both ways: a burst can run over the limit for a while before it&#8217;s caught, and a client that has slowed down can stay limited for a short time after. AWS&#8217;s own caveats page gives the typical delay as under 30 seconds, with longer possible.</p>



<p class="wp-block-paragraph">Two consequences follow:</p>



<ul class="wp-block-list">

<li><strong>Don&#8217;t use WAF to enforce billing quotas or contractual API limits.</strong> If &#8220;1,000 calls per customer per hour&#8221; is in a contract, count it in your application, where you control the number exactly and can show it to the customer. API Gateway usage plans help, but AWS describes their throttling and quotas as best effort too.</li>


<li><strong>Editing a live rule resets its counters.</strong> Changing the limit, window, key, forwarded IP config or scope-down resets the rule&#8217;s counts and can pause its rate limiting for up to a minute. Tuning during an active attack gives the attacker a free minute each time.</li>

</ul>



<h2 class="wp-block-heading">Rolling out AWS WAF rate-based rules without collateral damage</h2>



<p class="wp-block-paragraph">The order below is the one I reach for first, because each step produces the evidence the next step needs.</p>



<ol class="wp-block-list">

<li><strong>Turn on WAF logging before anything else.</strong> Send logs to CloudWatch Logs, S3 or Firehose. The destination name has to start with <code>aws-waf-logs-</code>. Without logs you&#8217;re tuning blind. If you want a longer retention and audit setup around them, that&#8217;s its own job: <a href="/aws/logging-audit/">AWS logging and audit trails</a>.</li>


<li><strong>Measure real traffic per key.</strong> Look at the busiest sources per five-minute bucket over a normal week, including your peak hour and any batch windows. The query further down does this in CloudWatch Logs Insights.</li>


<li><strong>Deploy every new rate rule in Count.</strong> Count mode evaluates the rule and records matches without affecting the request. Give it at least one full business cycle, ideally including a month-end or a marketing send.</li>


<li><strong>Review what would have been blocked.</strong> For each counted match, ask whether it was an attacker, a customer, a partner, a crawler you want, or your own monitoring. The last one catches people out: uptime checks and synthetic tests often run from a small pool of addresses.</li>


<li><strong>Set the limit above the busiest legitimate bucket, with headroom.</strong> The goal is to sit clearly between your heaviest real client and the flood, not to hug the average.</li>


<li><strong>Switch to Block with a 429 response,</strong> and add an alarm on the rule&#8217;s blocked request metric so a sudden jump reaches a human.</li>

</ol>



<p class="wp-block-paragraph">Here&#8217;s the Logs Insights query for step two, run against the WAF log group. It shows the heaviest client IPs per five-minute bin:</p>



<pre class="wp-block-code"><code>fields httpRequest.clientIp
| stats count(*) as requests by httpRequest.clientIp, bin(5m)
| sort requests desc
| limit 25</code></pre>



<p class="wp-block-paragraph">Swap <code>httpRequest.clientIp</code> for <code>httpRequest.uri</code> to find the hottest paths, or filter on a URI to size a scoped rule. At high volume, logs in S3 queried with Athena are usually cheaper to explore than repeated Logs Insights scans.</p>



<h2 class="wp-block-heading">Troubleshooting a customer who got rate limited</h2>



<p class="wp-block-paragraph">When the ticket arrives, work through it in this order:</p>



<ol class="wp-block-list">

<li><strong>Confirm it was WAF.</strong> A WAF block never reaches your application logs. Search WAF logs for the customer&#8217;s IP or API key and check <code>terminatingRuleId</code> and <code>action</code>.</li>


<li><strong>List what the rule is currently limiting.</strong> For rules aggregated only on IP or forwarded IP, AWS WAF can return the addresses currently being limited. The command is shown below. It won&#8217;t work for custom-key rules; for those, the logs are your only view.</li>


<li><strong>Check which address WAF saw.</strong> If it&#8217;s a CloudFront or CDN range, your rule is counting the proxy. If it&#8217;s the customer&#8217;s office NAT, the limit is fine for a person and wrong for an organization.</li>


<li><strong>Check for traffic you didn&#8217;t expect.</strong> A retry loop, a misconfigured cron job or a client polling far more often than it needs to will look exactly like abuse. Sometimes the fix is on their side, and the logs give you the evidence to say so politely.</li>


<li><strong>Fix the scope or key, not just the number.</strong> Raising the limit for everyone to fit one heavy customer weakens the rule for every attacker too.</li>

</ol>



<pre class="wp-block-code"><code>aws wafv2 get-rate-based-statement-managed-keys 
  --scope REGIONAL 
  --region eu-west-1 
  --web-acl-name my-web-acl 
  --web-acl-id 11111111-2222-3333-4444-555555555555 
  --rule-name rate-login</code></pre>



<p class="wp-block-paragraph">For a CloudFront web ACL, use <code>--scope CLOUDFRONT</code> with <code>--region us-east-1</code>. If the rule sits inside a rule group, add <code>--rule-group-rule-name</code> with the name of the rule group reference in your web ACL. A single rate-based rule instance limits at most 10,000 addresses at once; beyond that, the highest-rate addresses are the ones limited.</p>



<h2 class="wp-block-heading">Common mistakes</h2>



<ul class="wp-block-list">

<li>Putting an IP-keyed rate rule on an ALB behind a CDN and never checking which IP WAF sees.</li>


<li>Trusting the first address in <code>X-Forwarded-For</code> when nothing you control overwrites it.</li>


<li>Keying on a header or cookie with no companion rule for requests that don&#8217;t carry it.</li>


<li>One site-wide limit instead of scoped rules for login, expensive endpoints and the API.</li>


<li>Going straight to Block without a Count period on real traffic.</li>


<li>Returning 403 for a rate limit, or Challenge on endpoints non-browser clients call.</li>


<li>Exempting a partner with Allow and silently removing every protection below it.</li>


<li>Tweaking a live rule repeatedly during an incident and resetting its counters each time.</li>

</ul>



<h2 class="wp-block-heading">Best practices</h2>



<ul class="wp-block-list">

<li>Put IP-based rate rules on the web ACL closest to the real client, usually the CloudFront distribution.</li>


<li>Size limits from logged peak traffic per key, not from guesses about &#8220;normal&#8221; users.</li>


<li>Alarm on sudden changes in blocked requests per rule, in CloudWatch or whatever monitoring stack you already watch, such as Grafana or Datadog. <a href="/aws/monitoring-alerting/">Alerts that fire only when customers are affected</a> is the goal.</li>


<li>Keep contractual quotas in the application; use WAF for floods and abuse.</li>


<li>Consider AWS Shield Advanced only if you actually need its DDoS response support and cost protection; rate-based rules alone handle a lot of ordinary abuse.</li>

</ul>



<h2 class="wp-block-heading">FAQ</h2>



<h3 class="wp-block-heading">What is a rate-based rule in AWS WAF?</h3>



<p class="wp-block-paragraph">It&#8217;s a rule that counts requests per aggregation key (by default, per source IP) over a look-back window and applies an action, such as Block or Count, to keys that go over a limit you set. It&#8217;s aimed at floods, brute force and scraping rather than exact quota enforcement.</p>



<h3 class="wp-block-heading">Why is AWS WAF blocking legitimate users?</h3>



<p class="wp-block-paragraph">Usually because many real users share one key: an office NAT, carrier-grade NAT, a VPN exit node, or a CDN or load balancer whose address WAF sees instead of the client&#8217;s. Check which IP appears in the WAF log for the blocked request.</p>



<h3 class="wp-block-heading">Should I use IP or forwarded IP aggregation behind CloudFront?</h3>



<p class="wp-block-paragraph">Where you can, put the rule on the CloudFront web ACL and use plain IP aggregation, since WAF sees the viewer&#8217;s address there. Forwarded IP on an ALB uses the first address in the header, which the client can forge unless something you control overwrites it.</p>



<h3 class="wp-block-heading">How do I return 429 instead of 403 from AWS WAF?</h3>



<p class="wp-block-paragraph">Use a Block action with a custom response: set the response code to 429 and add a <code>Retry-After</code> response header. You can also attach a custom response body defined on the web ACL.</p>



<h3 class="wp-block-heading">Why didn&#8217;t my rate-based rule block at exactly the limit?</h3>



<p class="wp-block-paragraph">AWS WAF estimates request rates and doesn&#8217;t guarantee an exact limit match. There&#8217;s also a detection delay, and editing the rule resets its counts. For exact per-client quotas, count in the application.</p>



<h3 class="wp-block-heading">Can I see which clients a rate-based rule is currently blocking?</h3>



<p class="wp-block-paragraph">Yes, for rules that aggregate only on IP or forwarded IP, via <code>GetRateBasedStatementManagedKeys</code>. Rules with custom keys don&#8217;t support that call, so use WAF logs instead.</p>



<h2 class="wp-block-heading">Conclusion</h2>



<p class="wp-block-paragraph">The one thing worth remembering about AWS WAF rate-based rules: the limit is the easy part. What decides if you block the attacker or your best customer is <em>what counts as one client</em>, and that choice is made by the aggregation key, the scope-down and where the web ACL sits. Log first, count before you block, give each kind of traffic its own rule, and answer with a 429 that tells well-behaved clients how to back off.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading">Need help tuning AWS WAF rate limits?</h2>



<p class="wp-block-paragraph">I help teams put rate limiting in front of AWS workloads that stops abuse and leaves real traffic alone. That usually covers:</p>



<ul class="wp-block-list">

<li>Reviewing an existing web ACL to find rules that count proxies, shared NATs or spoofable headers as single clients.</li>


<li>Moving IP-based rate rules to the right layer when CloudFront or another CDN sits in front of an ALB or API Gateway.</li>


<li>Designing scoped rules for login, signup, OTP and expensive endpoints, with composite keys for authenticated APIs.</li>


<li>Setting up WAF logging and the queries that size limits from your real peak traffic.</li>


<li>Running new rules in Count mode, reviewing what they&#8217;d catch, and switching to Block with 429 responses and alarms.</li>


<li>Untangling a live incident where customers or partners are being rate limited and you need to know why.</li>

</ul>



<p class="wp-block-paragraph">If a customer is getting blocked right now, send me the rule JSON and one redacted WAF log entry for the blocked request. That&#8217;s usually enough to see which of the four failure families you&#8217;re in.</p>



<div class="wp-block-buttons is-layout-flex wp-block-buttons-is-layout-flex">
<div class="wp-block-button"><a class="wp-block-button__link wp-element-button" href="https://john-nessime.com/aws/waf-protection/">See the AWS WAF protection service</a></div>



<div class="wp-block-button is-style-outline is-style-outline--1"><a class="wp-block-button__link wp-element-button" href="https://www.upwork.com/freelancers/~01f15a912ad84a6620" target="_blank" rel="noreferrer noopener">Work with me on Upwork</a></div>
</div>
<p>The post <a href="https://john-nessime.com/blog/devops/aws-waf-rate-based-rules/">AWS WAF Rate-Based Rules: Stop the Flood, Not Your Best Customer</a> appeared first on <a href="https://john-nessime.com/blog">John Nessime</a>.</p>
]]></content:encoded>
					
		
		
			</item>
	</channel>
</rss>
