How to fix API rate limit exceeded in Git

# Check rate limit (unauthenticated)
curl -s https://api.github.com/rate_limit | jq '.rate'

# Check rate limit (authenticated)
curl -s -H "Authorization: Bearer YOUR_TOKEN" \
  https://api.github.com/rate_limit | jq '.rate'

{
  "limit": 5000,
  "remaining": 4892,
  "reset": 1699999999,
  "used": 108,
  "resource": "core"
}

# On macOS
date -r 1699999999

# On Linux
date -d @1699999999

curl -H "Authorization: Bearer ghp_xxxxxxxxxxxx" \
  https://api.github.com/user/repos

import requests

headers = {
    "Authorization": "Bearer ghp_xxxxxxxxxxxx",
    "Accept": "application/vnd.github+json"
}

response = requests.get(
    "https://api.github.com/user/repos",
    headers=headers
)

const response = await fetch("https://api.github.com/user/repos", {
  headers: {
    "Authorization": "Bearer ghp_xxxxxxxxxxxx",
    "Accept": "application/vnd.github+json"
  }
});

export GITHUB_TOKEN=ghp_xxxxxxxxxxxx

curl -H "Authorization: Bearer $GITHUB_TOKEN" \
  https://api.github.com/user/repos

import requests
import time

def make_github_request(url, token):
    headers = {"Authorization": f"Bearer {token}"}
    response = requests.get(url, headers=headers)

    # Check rate limit headers
    remaining = int(response.headers.get("X-RateLimit-Remaining", 0))
    reset_time = int(response.headers.get("X-RateLimit-Reset", 0))

    if remaining < 10:
        wait_time = reset_time - time.time()
        if wait_time > 0:
            print(f"Rate limit low. Waiting {wait_time:.0f} seconds...")
            time.sleep(wait_time + 1)

    return response

async function makeGitHubRequest(url, token) {
  const response = await fetch(url, {
    headers: { "Authorization": `Bearer ${token}` }
  });

  const remaining = parseInt(response.headers.get("X-RateLimit-Remaining"));
  const resetTime = parseInt(response.headers.get("X-RateLimit-Reset"));

  if (remaining < 10) {
    const waitTime = (resetTime * 1000) - Date.now();
    if (waitTime > 0) {
      console.log(`Rate limit low. Waiting ${waitTime/1000}s...`);
      await new Promise(resolve => setTimeout(resolve, waitTime + 1000));
    }
  }

  return response;
}

import requests
import time

def github_request_with_retry(url, token, max_retries=3):
    headers = {"Authorization": f"Bearer {token}"}

    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)

        if response.status_code == 200:
            return response

        if response.status_code in (403, 429):
            # Check for rate limit
            remaining = int(response.headers.get("X-RateLimit-Remaining", 1))

            if remaining == 0:
                reset_time = int(response.headers.get("X-RateLimit-Reset", 0))
                wait_time = max(reset_time - time.time(), 0) + 1

                # Also check retry-after header
                retry_after = response.headers.get("Retry-After")
                if retry_after:
                    wait_time = max(wait_time, int(retry_after))

                print(f"Rate limited. Waiting {wait_time:.0f}s (attempt {attempt + 1})")
                time.sleep(wait_time)
                continue

        # Exponential backoff for other errors
        wait_time = (2 ** attempt) * 1
        time.sleep(wait_time)

    return response  # Return last response after all retries

async function githubRequestWithRetry(url, token, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url, {
      headers: { "Authorization": `Bearer ${token}` }
    });

    if (response.ok) return response;

    if (response.status === 403 || response.status === 429) {
      const remaining = parseInt(response.headers.get("X-RateLimit-Remaining"));

      if (remaining === 0) {
        const resetTime = parseInt(response.headers.get("X-RateLimit-Reset"));
        const retryAfter = response.headers.get("Retry-After");

        let waitTime = Math.max((resetTime * 1000) - Date.now(), 0) + 1000;
        if (retryAfter) {
          waitTime = Math.max(waitTime, parseInt(retryAfter) * 1000);
        }

        console.log(`Rate limited. Waiting ${waitTime/1000}s`);
        await new Promise(r => setTimeout(r, waitTime));
        continue;
      }
    }

    // Exponential backoff
    await new Promise(r => setTimeout(r, Math.pow(2, attempt) * 1000));
  }

  throw new Error("Max retries exceeded");
}

import requests

class GitHubClient:
    def __init__(self, token):
        self.token = token
        self.etag_cache = {}  # Store ETags by URL
        self.data_cache = {}  # Store responses by URL

    def get(self, url):
        headers = {"Authorization": f"Bearer {self.token}"}

        # Add If-None-Match if we have a cached ETag
        if url in self.etag_cache:
            headers["If-None-Match"] = self.etag_cache[url]

        response = requests.get(url, headers=headers)

        if response.status_code == 304:
            # Data unchanged, return cached version
            print("Using cached data (304 Not Modified)")
            return self.data_cache[url]

        if response.status_code == 200:
            # Cache the new data and ETag
            etag = response.headers.get("ETag")
            if etag:
                self.etag_cache[url] = etag
                self.data_cache[url] = response.json()
            return response.json()

        response.raise_for_status()

# Usage
client = GitHubClient("ghp_xxxxxxxxxxxx")
repos = client.get("https://api.github.com/user/repos")
# Second call returns cached data if unchanged
repos = client.get("https://api.github.com/user/repos")

# Get user info (1 request)
GET /users/octocat

# Get user repos (1 request)
GET /users/octocat/repos

# Get each repo's issues (N requests)
GET /repos/octocat/repo1/issues
GET /repos/octocat/repo2/issues
# ... more requests

curl -X POST https://api.github.com/graphql \
  -H "Authorization: Bearer ghp_xxxxxxxxxxxx" \
  -d '{
    "query": "query { user(login: \"octocat\") { name repositories(first: 10) { nodes { name issues(first: 5) { nodes { title } } } } } }"
  }'

import requests

def graphql_query(token, query, variables=None):
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json"
    }

    payload = {"query": query}
    if variables:
        payload["variables"] = variables

    response = requests.post(
        "https://api.github.com/graphql",
        headers=headers,
        json=payload
    )
    return response.json()

# Fetch user and repos in one request
query = """
query($login: String!) {
  user(login: $login) {
    name
    repositories(first: 10, orderBy: {field: UPDATED_AT, direction: DESC}) {
      nodes {
        name
        stargazerCount
        issues(first: 5, states: OPEN) {
          totalCount
          nodes {
            title
          }
        }
      }
    }
  }
}
"""

result = graphql_query(token, query, {"login": "octocat"})

import time
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_user(token, username, ttl_hash=None):
    """Cache user data. ttl_hash changes to invalidate cache."""
    import requests
    response = requests.get(
        f"https://api.github.com/users/{username}",
        headers={"Authorization": f"Bearer {token}"}
    )
    return response.json()

def get_ttl_hash(seconds=300):
    """Return same value within 'seconds' window."""
    return round(time.time() / seconds)

# Usage - cached for 5 minutes
user = get_cached_user(token, "octocat", get_ttl_hash(300))

import redis
import json
import requests

r = redis.Redis(host='localhost', port=6379, db=0)

def get_github_data(url, token, cache_ttl=300):
    # Check cache first
    cache_key = f"github:{url}"
    cached = r.get(cache_key)

    if cached:
        return json.loads(cached)

    # Fetch from API
    response = requests.get(url, headers={
        "Authorization": f"Bearer {token}"
    })

    if response.status_code == 200:
        data = response.json()
        # Cache for 5 minutes
        r.setex(cache_key, cache_ttl, json.dumps(data))
        return data

    return None

# Cache GitHub API responses with curl
CACHE_FILE="/tmp/github_cache_$(echo $URL | md5sum | cut -d' ' -f1)"
CACHE_TTL=300  # 5 minutes

if [ -f "$CACHE_FILE" ]; then
    AGE=$(($(date +%s) - $(stat -c %Y "$CACHE_FILE")))
    if [ $AGE -lt $CACHE_TTL ]; then
        cat "$CACHE_FILE"
        exit 0
    fi
fi

curl -s -H "Authorization: Bearer $GITHUB_TOKEN" "$URL" | tee "$CACHE_FILE"

- name: Check rate limit
  run: |
    curl -s -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
      https://api.github.com/rate_limit | jq '.rate'

- name: API call with PAT
  env:
    GH_TOKEN: ${{ secrets.PAT_TOKEN }}  # 5,000/hour limit
  run: |
    gh api /repos/owner/repo/issues

- name: Make API request with retry
  uses: nick-fields/retry@v2
  with:
    timeout_minutes: 5
    max_attempts: 3
    retry_wait_seconds: 60
    command: |
      curl -f -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
        https://api.github.com/repos/${{ github.repository }}/issues

jobs:
  setup:
    runs-on: ubuntu-latest
    outputs:
      data: ${{ steps.fetch.outputs.data }}
    steps:
      - id: fetch
        run: |
          DATA=$(curl -s -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
            https://api.github.com/repos/${{ github.repository }})
          echo "data=$DATA" >> $GITHUB_OUTPUT

  matrix-job:
    needs: setup
    strategy:
      matrix:
        item: [1, 2, 3]
    steps:
      # Use cached data instead of making API calls
      - run: echo '${{ needs.setup.outputs.data }}' | jq .