# The Weekly Repo Refresh Playbook: Watchlist to a Budgeted Delta Log

*Size a weekly repo refresh against a written budget, run it in a fixed order, and sort every changed row as updated, moved, gone, or unverified.*

- Canonical URL: https://www.refolk.ai/guides/weekly-repo-refresh-playbook
- Pillar: Process, data, and compliance
- Format: Playbook
- Published: 2026-11-18
- Last reviewed: 2026-11-18
- Reading time: 21 min
- Keywords: how to keep GitHub data up to date incrementally, GitHub API rate limit budget for weekly sync, handle renamed or transferred repos in GitHub API, GitHub ETag conditional requests 304 rate limit, detect deleted GitHub users in stored dataset, GH Archive backfill missed events

## Key takeaways

- A 304 Not Modified response only spares GitHub's primary rate limit when the request carried an Authorization header; one measured unauthenticated test saw three conditional requests cost three.
- GraphQL cannot be made conditional, so a weekly refresh should run authenticated If-None-Match REST checks first and spend GraphQL points only on rows that came back 200.
- At the 900-points-per-minute REST cap, even a 15,000-per-hour GitHub App can use its whole hourly budget in 16.7 minutes, so pacing decides how long a weekly refresh takes.
- A renamed or transferred repo returns 301 with a Location of /repositories/{id}, so every stored row should be keyed by numeric repo ID with owner/name kept only as a display alias.
- One unhandled 451 can halt the refresh loop and leave every later row silently stale, so a clean run requires rows attempted to equal watchlist size.
- GH Archive does not backfill its own missed hours and has no rename event, so an archive backfill must count hourly files and join on repo.id, never on repo name.

This playbook is for the recruiting operations or revenue operations owner who keeps a stored list of watched GitHub repos, orgs, and contributors and has to answer for how current it is. It gives you a written rate-limit budget, a fixed weekly run order, and a delta log that sorts every changed row as updated, moved, gone, or unverified before sourcing or sales acts on it. Choosing a collection route, merging identities, and clearing contacts are separate jobs. This one keeps an existing dataset correct week after week.

## What does a weekly repo refresh have to produce?

A weekly refresh has to produce one delta log: every row on the watchlist attempted, every changed row sorted into exactly one of four states, and one run-health line showing whether the planned budget held. A run that cannot show all three is not finished, however many rows it touched.

Terms used throughout:

- **Watchlist:** the stored set of repos, orgs, and contributor accounts you re-check every week.
- **ETag:** a version tag the GitHub REST API returns with a response. You send it back next time to ask whether the resource has changed.
- **Conditional request:** a GET that carries the stored ETag in an `If-None-Match` header. If nothing changed, the API answers `304 Not Modified` with no body.
- **Tombstone:** a row you keep, with its numeric ID, a gone flag, a reason, and a date, instead of deleting it. The next run skips it and downstream tools suppress it.
- **Delta log:** the per-run record of what changed, what state each changed row landed in, and why.

The four states:

| State | Trigger | What happens to the row |
|---|---|---|
| Updated | 200 with new content | Fields refreshed, key unchanged |
| Moved | 301 resolved to a new ID | Re-keyed, alias updated |
| Gone | Confirmed missing or blocked | Tombstoned, suppressed downstream |
| Unverified | Error, ambiguity, hop cap hit | Held, retried once, not acted on |

Rows that return 304 are unchanged. Log them as a count, not as deltas. The point of the four states is that nobody downstream has to interpret a raw status code. A sourcer reading "moved" knows the repo has a new owner. A sales lead reading "gone" knows not to sequence that account.

## How large is the weekly budget for each GitHub credential?

The credential sets your hourly budget, but the per-minute cap decides how long the run takes. Authenticated users get 5,000 REST requests an hour, anonymous callers get 60, and GitHub Apps owned by an Enterprise Cloud organization get 15,000.

| Credential | REST per hour | GraphQL points per hour | Minutes to drain at 900/min |
|---|---|---|---|
| Anonymous | 60 | n/a | under 1 |
| PAT or OAuth app | 5,000 | 5,000 | 5.6 |
| App, not Enterprise Cloud | 5,000 to 12,500 | 5,000 to 12,500 | 5.6 to 13.9 |
| App on Enterprise Cloud | 15,000 | 10,000 | 16.7 |

The last column is derived: the hourly REST limit divided by the 900-points-per-minute secondary cap. App installations outside Enterprise Cloud start at 5,000 and scale toward 12,500 with the number of repositories and users. OAuth app tokens follow the authenticated-user limits.

Secondary limits sit on top of the hourly figure:

- No more than **100 concurrent requests**, shared across REST and GraphQL.
- **900 points per minute** for REST endpoints.
- **2,000 points per minute** for the GraphQL endpoint.
- Most REST GET, HEAD, and OPTIONS requests cost 1 point, but some endpoints have a point cost that GitHub does not publish.
- Secondary limits are subject to change without notice.

**16.7 min - Time for a 15,000-per-hour GitHub App to hit its hourly REST budget at the 900-per-minute cap**

Pacing binds before the total does, so the budget sheet has to plan minutes, not just requests.

#### The layers of a refresh budget

1. **Policy** - One credential per pipeline; no token pooling; excessive requests risk suspension
2. **Hourly primary limit** - 60, 5,000, up to 12,500, or 15,000 REST requests by credential
3. **Per-minute secondary cap** - 900 points for REST, 2,000 points for GraphQL
4. **Concurrency ceiling** - 100 in-flight requests shared across REST and GraphQL
5. **Per-request cost** - Usually 1 point for REST GET; some endpoints unpublished

*A weekly refresh has to fit inside every layer at once, from the terms of service down to the cost of a single request.*

### Sizing the weekly run

Size the run with four lines of arithmetic:

1. **Planned REST calls** = watchlist rows × REST endpoints checked per row + expected redirect hops + retries.
2. **Minimum REST minutes** = planned calls ÷ 900.
3. **Hourly fit** = planned calls compared against the credential's hourly limit.
4. **GraphQL points** = rows that returned 200 × points per query, measured on your own queries.

Worked example: a 500-repo watchlist checked on five REST endpoints is 2,500 calls. At the 900-per-minute cap that is at least 3 minutes. Paced to fit inside 5,000 an hour, it is about 30 minutes.

Two honest limits on this arithmetic. First, an authenticated 304 does not count against the primary limit. I found nothing establishing whether it counts toward the per-minute secondary points, so plan as if it does. Second, nobody has published measured ETag savings for a 500-repo weekly watchlist. The only worked example is illustrative: 50 repositories polled every 5 minutes make 600 requests an hour, and if 90% are unchanged, only 60 count. Your weekly cadence will see more change per check than a five-minute poll, so measure your own 304 rate over the first few runs before you count on savings.

> **Rule:** One credential per pipeline, never pooled
>
> GitHub's terms state that you may not share API tokens to exceed GitHub's rate limitations. Size the run to one named credential, and if it does not fit, change the credential type rather than adding tokens.

**Refresh budget sheet**

```
Pipeline name:
Credential (one only): PAT / OAuth app / App installation / App on Enterprise Cloud
REST requests per hour for this credential:
GraphQL points per hour for this credential:
REST per-minute cap: 900 points
GraphQL per-minute cap: 2,000 points
Concurrency ceiling: 100 (shared REST + GraphQL); this pipeline runs serially
Watchlist rows (repos / orgs / contributors):
REST endpoints checked per row:
Expected redirect hops (last run's 301 count x hop cap):
Retry allowance:
Planned REST calls:
Minimum REST minutes (planned calls / 900):
Planned GraphQL points (expected 200 rows x measured points per query):
Archive bytes estimate for backfill window:
Owner signature and date:
```

*Fill one sheet per pipeline; re-sign it whenever the credential or watchlist size changes, and at least quarterly.*

## Why does the run go REST first, then GraphQL, then the archive?

The order is forced by the protocol: conditional requests work on the REST API but not on GraphQL, so only REST checks can filter out unchanged rows before you spend points. The archive goes last because it only fills hours your own run did not cover.

A GraphQL query spends points whether or not anything changed. If you lead with GraphQL, you pay full price for every unchanged row every week. If you lead with authenticated `If-None-Match` checks, every 304 drops out for free on the primary limit, and GraphQL only touches rows that returned 200.

#### The weekly refresh run order

1. **Conditional REST checks** - Serial, authenticated If-None-Match GETs tag every row by status
2. **Redirect resolution** - 301s followed to api.github.com, re-keyed by numeric ID
3. **Targeted GraphQL** - Detail pulled only for rows that returned 200
4. **Archive backfill** - Missed hours queried by repo.id, missing files counted
5. **Delta log** - Every changed row sorted and budget compared against plan

*Each stage narrows what the next stage has to touch, so unchanged rows never reach GraphQL and the archive only fills gaps.*

Where sources disagree: one GitHub community answer recommends webhooks first, with occasional syncs via conditional requests, rather than polling first. That is the cheaper design wherever webhooks are available to you. This playbook covers the case where they are not, and it doubles as the periodic sync in a webhook-first setup.

## What does each GitHub response mean for a stored row?

Each status code maps to one action on the stored row: 304 means leave it, 200 means refresh it, 301 means re-key it, 451 means tombstone it with a reason, and anything the sources do not pin down means hold it as unverified. Write this map into the job before the first run, not after the first surprise.

| Case | Status | Body or Location |
|---|---|---|
| Rename or transfer (GET) | 301 | /repositories/{id} |
| Rename or transfer (write) | 307 | /repositories/{id} |
| DMCA takedown | 451 | block.reason "dmca" |
| Terms-of-service block | 451 | block.reason "tos" |
| Deleted repo or user | not established | not established |

What each row proves, and where it lies:

- **301 proves the numeric ID survived.** The redirect target is `/repositories/{id}`, which is why the numeric ID, not the name, is the key. A real example: `joyent/node` redirects to `repositories/211666`. It lies when your client refuses to follow it or follows it without auth; the row then looks deleted.
- **307 appears on writes.** A read-only refresh should not see it. If it does, something in the job is sending DELETE or POST.
- **451 proves the repo is blocked, not deleted.** The DMCA body reads "Repository access blocked" with a `block.reason` field; a terms-of-service block carries `"reason":"tos"`. The 451 response is missing from GitHub's published REST schema (rest-api-description issue #3314), so do not assume a client generated from the schema handles it. Write that branch yourself.
- **403 or 429 with `x-ratelimit-remaining` at 0 is your own budget, not the row.** Stop. GitHub warns that continuing to request while rate limited may get the integration banned.
- **A secondary-limit error means wait at least one minute**, then back off exponentially before retrying.

> **Note:** Test the unverified responses on accounts you control
>
> The response for a deleted repo, a deleted or suspended user, and a renamed owner login is not established in any source I trust, and user-ID stability across login changes is not documented. Create a throwaway repo and org, rename, transfer, and delete them, record each status code, and pin the results in the job's response map.

Until that local test is done, treat a first 404 as unverified, not gone. Contributor rows keyed by numeric user ID are the best available practice, but mark them as relying on an undocumented guarantee.

## The weekly refresh procedure, step by step

Run these seven steps in order every week; steps 1 and 2 are one-time setup that you revisit only when the credential or watchlist changes. The time figures are derived from the rate limits, because no source publishes stage timings.

#### Weekly repo dataset refresh

1. **Write the budget** - Record requests per hour for the pipeline's credential, the 900 REST and 2,000 GraphQL points-per-minute caps, and the 100-request concurrency ceiling. Done is a signed sheet naming exactly one credential per pipeline, written in about 30 minutes and revisited quarterly.
2. **Key the watchlist by numeric ID** - Give every repo row a numeric repo_id and store the owner/name pair only as a display alias. Expect 1 to 2 engineer hours the first time; done is zero rows without a repo_id.
3. **Run conditional REST checks** - Send serial, authenticated GET requests carrying the stored ETag in If-None-Match, paced under the per-minute cap. Done is every row tagged 200, 304, 301, 404, 451, or error.
4. **Resolve redirects** - Follow a 301 only when it points at api.github.com, keep the Authorization header, cap hops at 3 to 5, and charge every hop to the budget. Done is each redirected row re-keyed to its new numeric ID and marked moved, or marked unverified if the chain did not resolve.
5. **Pull targeted GraphQL data for 200 rows** - Run GraphQL queries only for rows whose REST check returned 200, because GraphQL cannot be made conditional. Done is fresh fields for every changed row and a recorded points total compared against the plan.
6. **Backfill missed windows from the archive** - List the hours the run or the previous run did not cover, count the archive's hourly files for those hours, and query them by repo.id. Done, in under an hour of analyst time, is a gap list with any missing hourly files named.
7. **Write the delta log and run-health check** - Sort every changed row as updated, moved, gone, or unverified, tombstone the gone rows, and compare budget used against the plan. Done, in about 15 minutes, is a log an ops owner can sign and hand to sourcing and sales.

| Stage | Owner | Time |
|---|---|---|
| Budget sheet | Ops owner | About 30 min, quarterly |
| Numeric-ID keying | Engineer | 1 to 2 h, first time |
| REST checks and redirects | Automated | 3 to 30 min per 2,500 calls |
| Archive backfill | Analyst | Under 1 h |
| Delta log | Ops owner | About 15 min |

Notes that keep each step honest:

- **Step 3, serial not concurrent.** GitHub's REST guidance is to make requests serially instead of concurrently. Serial requests also make the 100-concurrency ceiling a non-issue and keep a single bad row from cascading.
- **Step 3, auth on every request.** A 304 only spares the primary limit when the request carried a valid `Authorization` header.
- **Step 4, hop cap.** Practitioner fixes use 3 to 5 hops. A chain longer than that goes to unverified, not moved.
- **Step 6, join on ID.** The archive has no rename event, so a name join silently loses every moved repo.
- **Step 6, cost.** The archive's BigQuery dataset updates hourly and includes 1 TB of processed data a month free. Nobody has published the bytes a one-week backfill scans for a given number of repos, so check the estimate your query tool reports before running, and write it on the budget sheet.

## Who should own the weekly run, and how do you find that person?

The run needs one accountable ops owner who signs the budget and the delta log, plus an engineer for the one-time keying and an analyst who can query the archive. In Refolk's index, the ops owner title is far more common in the US than in the UK, and it is spelled differently in each market.

**195 vs 27 - People holding Recruiting, Talent, or Recruitment Operations titles in the US vs the UK, in Refolk's index**

The US pool is 7.2 times the UK pool, and the two markets name the role differently.

| Market | People in Refolk's index | Most common title in a 25-person sample |
|---|---|---|
| US | 195 | "Recruiting Operations", 52% |
| UK | 27 | "Recruitment Operations", 48% |

In the UK sample, "Recruiting Operations" is only 3 of 25, or 12%. A search phrased the US way for the person who should own this runbook undercounts the UK. The UK sample's top employers include Anthropic (2), ElevenLabs, Perplexity, and Sierra, so AI companies are where UK ops owners of this kind of tooling cluster in the index. I only ran one market pair within the index's call cap, so treat other markets as unmeasured.

When you hire or borrow that owner, search both spellings at once. In [Refolk](/) you can ask in plain English for recruiting and recruitment operations people in a given city and get both title forms back without writing a boolean string.

The archive backfill is the step most teams cannot staff from inside ops. In Refolk's index, 87 data engineers in the US list BigQuery as a skill, with Meta and CVS Health the top employers at 3 each. That pool is small enough that the person who already runs your warehouse is usually the right first ask.

I ran this search: `US data engineers with BigQuery experience who have built GitHub data pipelines` - [see the full result list](https://www.refolk.ai/s/mjex3emwab).

*Returns named US data engineers whose public profiles and GitHub work show BigQuery and GitHub data pipeline experience, the skill pair the archive backfill step needs.*

## How does the weekly refresh go wrong?

The refresh usually fails quietly: dashboards look green while the budget drains, rows go stale behind one unhandled status, or a gap in the archive gets read as "nothing changed." Each failure below has a symptom that looks like success and a single check that exposes it.

1. **The 304 that still costs.** A 304 counts as zero only when the request was sent with auth. *False positive:* a dashboard full of 304s while the budget still drains. One measured test of unauthenticated conditional requests saw remaining go from 31 to 28, so three 304s cost three. *Check:* read `x-ratelimit-remaining` before and after a sample of 304s.
2. **The redirect follower drops auth or refuses the 301.** *False positive:* a stuck row that looks like a deleted repo. If the follower strips the `Authorization` header, the hop runs anonymously against the 60-per-hour limit. *Check:* the share of 301s that end up re-keyed. Anything short of all of them needs a reason in the log.
3. **Polling tombstoned rows.** GitHub states that repeatedly requesting a missing resource wastes your rate limit and can trigger a secondary limit. *False positive:* a stable run that quietly spends more every week as gone rows pile up. *Check:* tombstoned IDs are excluded from the next run's request list.
4. **An unhandled 451 halts the loop.** In one public case, a weekly refresh job kept failing after a single 451. In another, one 451 stopped a stale-marking loop so that a truly deleted repository was never marked stale. *False positive:* the run reports success on the rows it reached. *Check:* rows attempted equals watchlist size.
5. **Trusting the listing's `disabled` field.** One source shows a DMCA-blocked repo still returned by the user-repos listing with `disabled` false. Another shows the same field as true. *False positive:* a blocked repo carried as healthy. *Check:* a direct GET on each repo, not the listing.
6. **Treating archive silence as no change.** The archive crawler can go offline or hit the API rate limit and miss events, and it does not backfill them. Several hourly files in one week were partial or absent. When archive lag dropped from up to eight hours to near-immediate, 43 pull request fields disappeared from the public firehose at the same time. *False positive:* an empty backfill result. *Check:* the count of hourly files per backfill window. A short count is a gap, not a quiet week.
7. **Budget reports that leave out redirect hops.** If hops are not charged to the budget, a renamed-repo capture can send twice its bound while reporting the bound. *False positive:* a run-health line that says the budget held. *Check:* hops logged as their own line and added to spend.

> **Watch out:** A green run can be a half run
>
> If the loop stops on an unexpected status, every later row keeps last week's values and nothing flags it. Wrap each row's request so that any unhandled status lands that row in unverified and the loop moves on.

> A row you never tombstone is a request you pay for every week, forever.

The two archive failures share a root cause: faster archive data came with less detail. The backfill fills timing gaps, not field gaps. If a pull request field you depend on is among those cut from the firehose, the archive cannot restore it, and the row has to come from the API or stay unverified.

## How do you write the delta log and run-health check?

Sort every changed row by two questions: does the numeric ID still resolve, and is the evidence confirmed or ambiguous? Then add one run-health block comparing what you spent with what you planned. Public sources set no thresholds for a healthy run. The closest published practice is to report skipped checks as degraded instead of failing silently, and I build the health check on that.

#### Sorting a changed row

Horizontal axis runs from ID does not resolve to ID resolves. Vertical axis runs from Evidence ambiguous to Evidence confirmed.

| Quadrant | What it means |
| --- | --- |
| Gone | Confirmed 451 or second 404; tombstone with reason and date, suppress downstream |
| Updated or moved | 200 with change, or 301 re-keyed; refresh fields or update alias |
| Unverified, missing | First 404, error, or hop cap hit; retry once next run, do not act |
| Unverified, conflicting | Resolves but fields disagree, such as the disabled flag; direct GET before acting |

*A row is only tombstoned or re-keyed when the evidence is confirmed; everything ambiguous waits one run as unverified.*

**Delta log and run-health block**

```
RUN: <date> | pipeline: <name> | credential: <type>

DELTA ROWS
repo_id | prior_alias | new_alias | state | status_seen | reason | action
<id> | <owner/name> | <owner/name> | updated | 200 | content changed | fields refreshed
<id> | <owner/name> | <owner/name> | moved | 301 | rename or transfer | re-keyed
<id> | <owner/name> | - | gone | 451 | block.reason dmca | tombstoned, suppressed
<id> | <owner/name> | - | unverified | 404 | first sighting | retry next run

RUN HEALTH
watchlist_size:
rows_attempted:
rows_skipped (any above 0 = DEGRADED):
304_count:
redirect_hops_charged:
REST_calls_planned / used:
GraphQL_points_planned / used:
rate_limit_errors (403/429 with remaining 0):
secondary_limit_waits:
archive_hours_expected / hourly_files_found:
tombstoned_ids_excluded_from_this_run: yes / no
status: CLEAN / DEGRADED
signed:
```

*One file per run; keep the column names fixed so downstream suppression can read it without a human.*

My definition of a clean run, in the absence of a published standard: rows attempted equals watchlist size, no row was skipped, spend including redirect hops stayed at or under plan, no primary rate-limit error occurred, every archive window has its full count of hourly files or a named gap, and no tombstoned ID was requested. Anything short of that is degraded. Degraded is not a failure as long as it is reported, but it should not go to sourcing or sales as if it were clean.

#### Before you sign the run

- [ ] Rows attempted equals watchlist size, and rows skipped is zero or explained.
- [ ] Every request carried the Authorization header, confirmed by x-ratelimit-remaining on a sample of 304s.
- [ ] Every 301 is either re-keyed to a numeric repo ID or listed as unverified with a reason.
- [ ] Redirect hops are charged to the budget on their own line.
- [ ] Every 451 is tombstoned with its block.reason recorded and did not stop the loop.
- [ ] No first-sighting 404 was tombstoned without a confirming check.
- [ ] GraphQL ran only on rows that returned 200, and points used are compared against plan.
- [ ] Archive backfill windows list their hourly file counts, and any missing hours are named as gaps.
- [ ] Tombstoned IDs are excluded from next week's request list and pushed to downstream suppression.
- [ ] The status line reads CLEAN or DEGRADED, and the ops owner has signed it.

## How do you keep this playbook current?

Re-check the parts of this playbook that GitHub or the archive can change without telling you: the secondary limits, the response map, the archive's fields, and the policy terms. Put each on a calendar instead of waiting for a run to break.

- **Secondary limits, quarterly.** GitHub says they are subject to change without notice. At each budget-sheet review, re-read the REST best-practices and rate-limit pages and update the per-minute and concurrency lines.
- **Response map, whenever a new status appears.** Any status not in your map should land in unverified automatically. Then re-run the throwaway-account test and add the result to the map.
- **Archive fields, before any backfill query changes.** The archive has already lost pull request fields once. Before relying on a field, confirm it is still present in a recent hourly file.
- **Policy, at every budget review.** GitHub's terms forbid using the API to download data for spamming, including selling users' personal information to recruiters, headhunters, and job boards. They also require use of the information to comply with the GitHub Privacy Statement. The refresh exists to keep your own records accurate and to suppress people who are gone, and the delta log is your evidence of that.
- **Retention for gone accounts, once, then yearly.** No source gives a retention rule for tombstoned accounts. Write your own: what a tombstone keeps (numeric ID, reason, date) and when even that is purged. Have whoever answers for data protection sign it.

The work that pays back fastest is the numeric-ID keying in step 2. Once every row is keyed by ID, renames become routine re-keys, archive joins line up, and a gone row stays gone instead of coming back under a new name. If the watchlist also feeds sourcing, re-run the people search behind each moved repo's new owner in Refolk before anyone sends a message based on the old row.

## Frequently asked questions

### Do 304 Not Modified responses count against the GitHub rate limit?

Not against the primary limit, provided the request carried a valid Authorization header. GitHub's REST guidance states that a conditional request returning 304 does not count when made while correctly authorized. Without auth it still counts: one published test saw remaining drop from 31 to 28 across three unauthenticated 304s. Verify locally by reading x-ratelimit-remaining before and after a sample of your own 304s.

### Can I use ETags or conditional requests with the GitHub GraphQL API?

No. Conditional requests work on the REST API but not on GraphQL, so every GraphQL query spends points whether or not the data changed. That is why a weekly refresh should run authenticated If-None-Match REST checks first and send only rows that returned 200 to GraphQL. Gating GraphQL behind REST is the only way to skip unchanged rows before spending points.

### How do I handle a renamed or transferred repo in the GitHub API?

Follow the 301 and re-key the row by numeric repo ID. A GET on a renamed or transferred repo returns 301 Moved Permanently with a Location of /repositories/{id}; writes return 307 instead. Follow redirects only to api.github.com, keep the Authorization header on every hop, cap hops at 3 to 5, and count each hop against your budget. Store owner/name only as a display alias.

### How do I detect a deleted GitHub user or repo in a stored dataset?

Treat a first 404 as unverified, confirm it once on the next run, then tombstone the row and suppress it downstream. The exact response for a deleted repo, a deleted or suspended user, or a renamed owner login is not established in the sources I trust, so test it on throwaway accounts you control. Do not keep polling tombstoned rows; repeated requests for missing resources can trigger secondary limits.

### Can I pool several personal access tokens to get a bigger rate limit?

No. GitHub's Terms of Service state that you may not share API tokens to exceed GitHub's rate limitations, and excessively frequent requests can lead to temporary or permanent suspension of API access. Assign one credential per pipeline and size the run to it. If one personal token is too small, a GitHub App installation offers 5,000 to 12,500 requests per hour, or 15,000 on Enterprise Cloud.

### Should I use webhooks instead of a weekly polling refresh?

Use webhooks where they are available to you, and keep conditional polling as the periodic sync. One GitHub community answer recommends webhooks first with occasional syncs via conditional requests. For a watchlist of repos where you cannot receive events, the weekly conditional REST pass in this playbook is the floor, and the archive backfill covers hours it missed.

---

*From the Refolk guide library. I revise these guides rather than replacing them, so the current version is always at https://www.refolk.ai/guides/weekly-repo-refresh-playbook*
