diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7e559a0..604236d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,11 @@
+## 2.7.0 – 2025-02-26
+
+1. Add support for quota-limited feature flags
+
+## 2.6.0 - 2025-02-13
+
+1. Add method for fetching decrypted remote config flag payload
+
 ## 2.5.1 - 2024-12-19
 
 1. Adds a new, optional `distinct_id` parameter to group identify calls which allows specifying the Distinct ID for the event.
diff --git a/lib/posthog/feature_flags.rb b/lib/posthog/feature_flags.rb
index 3060487..60db174 100644
--- a/lib/posthog/feature_flags.rb
+++ b/lib/posthog/feature_flags.rb
@@ -25,7 +25,7 @@ def initialize(polling_interval, personal_api_key, project_api_key, host, featur
       @feature_flags_by_key = nil
       @feature_flag_request_timeout_seconds = feature_flag_request_timeout_seconds
       @on_error = on_error || proc { |status, error| }
-
+      @quota_limited = Concurrent::AtomicBoolean.new(false)
       @task =
         Concurrent::TimerTask.new(
           execution_interval: polling_interval,
@@ -136,6 +136,10 @@ def get_feature_flag(key, distinct_id, groups = {}, person_properties = {}, grou
     end
 
     def get_all_flags(distinct_id, groups = {}, person_properties = {}, group_properties = {}, only_evaluate_locally = false)
+      if @quota_limited.true?
+        logger.debug "Not fetching flags from decide - quota limited"
+        return {}
+      end
       # returns a string hash of all flags
       response = get_all_flags_and_payloads(distinct_id, groups, person_properties, group_properties, only_evaluate_locally)
       flags = response[:featureFlags]
@@ -170,8 +174,16 @@ def get_all_flags_and_payloads(distinct_id, groups = {}, person_properties = {},
           unless flags_and_payloads.key?(:featureFlags)
             raise StandardError.new("Error flags response: #{flags_and_payloads}")
           end
-          flags = stringify_keys(flags_and_payloads[:featureFlags] || {})
-          payloads = stringify_keys(flags_and_payloads[:featureFlagPayloads] || {})
+
+          # Check if feature_flags are quota limited
+          if flags_and_payloads[:quotaLimited]&.include?("feature_flags")
+            logger.warn "[FEATURE FLAGS] Quota limited for feature flags"
+            flags = {}
+            payloads = {}
+          else
+            flags = stringify_keys(flags_and_payloads[:featureFlags] || {})
+            payloads = stringify_keys(flags_and_payloads[:featureFlagPayloads] || {})
+          end
         rescue StandardError => e
           @on_error.call(-1, "Error computing flag remotely: #{e}")
           raise if raise_on_error
@@ -483,6 +495,17 @@ def _load_feature_flags()
         return
       end
 
+      # Handle quota limits with 402 status
+      if res.is_a?(Hash) && res[:status] == 402
+        logger.warn "[FEATURE FLAGS] Feature flags quota limit exceeded - unsetting all local flags. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts"
+        @feature_flags = Concurrent::Array.new
+        @feature_flags_by_key = {}
+        @group_type_mapping = Concurrent::Hash.new
+        @loaded_flags_successfully_once.make_false
+        @quota_limited.make_true
+        return
+      end
+
       if !res.key?(:flags)
         logger.debug "Failed to load feature flags: #{res}"
       else
@@ -530,16 +553,23 @@ def _request_remote_config_payload(flag_key)
     end
 
     def _request(uri, request_object, timeout = nil)
-
       request_object['User-Agent'] = `"posthog-ruby#{PostHog::VERSION}"`
-
       request_timeout = timeout || 10
 
       begin
-        res_body = nil
         Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https', :read_timeout => request_timeout) do |http|
           res = http.request(request_object)
-          JSON.parse(res.body, {symbolize_names: true})
+          
+          # Parse response body to hash
+          begin
+            response = JSON.parse(res.body, {symbolize_names: true})
+            # Only add status if response is a hash
+            response = response.is_a?(Hash) ? response.merge({status: res.code.to_i}) : response
+            return response
+          rescue JSON::ParserError
+            # Handle case when response isn't valid JSON
+            return {error: "Invalid JSON response", body: res.body, status: res.code.to_i}
+          end
         end
       rescue Timeout::Error,
              Errno::EINVAL,
diff --git a/lib/posthog/version.rb b/lib/posthog/version.rb
index 9e91494..de7e78d 100644
--- a/lib/posthog/version.rb
+++ b/lib/posthog/version.rb
@@ -1,3 +1,3 @@
 class PostHog
-  VERSION = '2.6.0'
+  VERSION = '2.7.1'
 end
diff --git a/spec/posthog/feature_flag_spec.rb b/spec/posthog/feature_flag_spec.rb
index e99fa7a..bfb719c 100644
--- a/spec/posthog/feature_flag_spec.rb
+++ b/spec/posthog/feature_flag_spec.rb
@@ -3738,9 +3738,9 @@ class PostHog
       ).to_return(status: 200, body: {"flags": flag_res}.to_json)
 
       stub_request(:post, decide_endpoint)
-        .to_return(status: 200, body:{
-          "featureFlags": {"beta-feature": "variant-1", "beta-feature2": "variant-2"},
-          "featureFlagPayloads": {"beta-feature": 100, "beta-feature2": 300},
+      .to_return(status: 200, body:{
+        "featureFlags": {"beta-feature": "variant-1", "beta-feature2": "variant-2", "disabled-feature": false},
+        "featureFlagPayloads": {"beta-feature": 100, "beta-feature2": 300},
       }.to_json)
 
       c = Client.new(api_key: API_KEY, personal_api_key: API_KEY, test_mode: true)
@@ -4008,6 +4008,49 @@ class PostHog
         expect(c.get_remote_config_payload(encrypted_payload_flag_key))
         assert_not_requested :post, decide_endpoint
     end
+
+    it 'handles quota limited response by unsetting all flags' do
+      flag_res = [
+        {
+          "id": 1,
+          "name": "Beta Feature",
+          "key": "beta-feature",
+          "is_simple_flag": false,
+          "active": true,
+          "rollout_percentage": 100,
+          "filters": {
+            "groups": [
+              {
+                "properties": [{"key": "country", "value": "US"}],
+                "rollout_percentage": 0,
+              }
+            ],
+            "payloads": {
+              "true": "payload-1",
+            },
+          },
+        }
+      ]
+
+      stub_request(
+        :get,
+        'https://app.posthog.com/api/feature_flag/local_evaluation?token=testsecret'
+      ).to_return(status: 200, body: {"flags": flag_res}.to_json)
+
+      stub_request(:post, decide_endpoint)
+        .to_return(status: 200, body: {
+          "featureFlags": {"beta-feature": true, "other-flag": false},
+          "featureFlagPayloads": {"beta-feature": "some-payload"},
+          "quotaLimited": ["feature_flags"]
+        }.to_json)
+
+      c = Client.new(api_key: API_KEY, personal_api_key: API_KEY, test_mode: true)
+
+      result = c.get_all_flags_and_payloads("distinct_id")
+      expect(result[:featureFlags]).to eq({})
+      expect(result[:featureFlagPayloads]).to eq({})
+      assert_requested :post, decide_endpoint, times: 1
+    end
   end
 
   describe 'resiliency' do
@@ -4061,5 +4104,69 @@ class PostHog
       expect(c.get_feature_flag("person-flag", "distinct_id", person_properties: {"region" => "USA"})).to eq(true)
       assert_not_requested :post, decide_endpoint
     end
+
+    it 'clears all flags when hitting quota limits (402 response)' do
+      # First load flags successfully
+      api_feature_flag_res = {
+        "flags": [
+          {
+            "id": 1,
+            "name": "Beta Feature",
+            "key": "person-flag",
+            "is_simple_flag": true,
+            "active": true,
+            "filters": {
+                "groups": [
+                    {
+                        "properties": [
+                            {
+                                "key": "region",
+                                "operator": "exact",
+                                "value": ["USA"],
+                                "type": "person",
+                            }
+                        ],
+                        "rollout_percentage": 100,
+                    }
+                ],
+            },
+          },]
+      }
+
+      stub_request(
+        :get,
+        'https://app.posthog.com/api/feature_flag/local_evaluation?token=testsecret'
+      ).to_return(status: 200, body: api_feature_flag_res.to_json)
+
+      # Add the exact stub for the decide endpoint as recommended in the error
+      stub_request(:post, "https://app.posthog.com/decide/?v=3").
+        with(
+          body: "{\"distinct_id\":\"distinct_id\",\"groups\":{},\"person_properties\":{\"distinct_id\":\"distinct_id\",\"region\":\"USA\"},\"group_properties\":{},\"token\":\"testsecret\"}",
+          headers: {
+            'Accept'=>'*/*',
+            'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+            'Content-Type'=>'application/json',
+            'Host'=>'app.posthog.com',
+            'User-Agent'=>''
+          }).
+        to_return(status: 200, body: "{\"featureFlags\": {}}", headers: {})
+
+      c = Client.new(api_key: API_KEY, personal_api_key: API_KEY, test_mode: true)
+
+      # Initial flag check should succeed
+      expect(c.get_feature_flag("person-flag", "distinct_id", person_properties: {"region" => "USA"})).to eq(true)
+
+      # Now simulate quota limit with 402 response
+      stub_request(
+        :get,
+        'https://app.posthog.com/api/feature_flag/local_evaluation?token=testsecret'
+      ).to_return(status: 402, body: {"error": "quota_limit_exceeded"}.to_json)
+
+      # Force reload to simulate poll interval
+      c.reload_feature_flags
+
+      # After quota limit, flag should return false (cleared)
+      expect(c.get_feature_flag("person-flag", "distinct_id", person_properties: {"region" => "USA"})).to eq(false)
+    end
   end
 end