If a public repository you maintain has a workflow triggered by pull_request_target, it has a date with a failed run. The first one is Monday, November 9, at 16:00 UTC. That's six days from now.
The change itself is good. pull_request_target is the trigger behind a long list of real supply-chain incidents, and blocking it by default closes the door most people didn't know was open. But "by default" means your workflow stops unless somebody decides otherwise. This post is about making that decision on purpose.
What GitHub announced
On November 2, 2026, GitHub said that starting December 2, GitHub Actions will block pull_request_target events by default in all public repositories, "unless an applicable Actions event policy explicitly allows them" (GitHub Changelog, November 2026). Enforcement had previously been scheduled for November 2. It moved a month.
The block comes from a default rule in workflow execution protections. Right now that rule runs in evaluate mode: it records which runs it would block and lets them through with warnings.
Scope, exactly as stated:
- Affected: public repositories on GitHub Free, GitHub Team and GitHub Enterprise Cloud.
- Not affected: private and internal repositories, and GitHub Enterprise Server.
GitHub's reason is the one security teams have been repeating for years. pull_request_target runs in the context of the base repository and can access its secrets. If that workflow executes untrusted code from a fork, the code can compromise the pipeline or steal secrets.
The two brownouts are a free rehearsal
Before permanent enforcement, GitHub will enforce the rule temporarily in two windows:
| Date | Window (UTC) |
|---|---|
| Monday, November 9, 2026 | 16:00–18:00 |
| Monday, November 16, 2026 | 16:00–18:00 |
During each window, a pull_request_target run that the default rule would block creates a failed run with an error annotation. The workflow doesn't execute. Afterwards the rule drops back to evaluate mode and runs go ahead with warnings.
Treat November 9 as the deadline, not December 2. A brownout is the cheapest possible way to find out what depends on this trigger: it fails for two hours and then stops failing. Those two hours fall in the working afternoon in Europe and the morning on the US East Coast, so someone will notice. If you've done the work by then, the brownout is a non-event. If you haven't, it tells you exactly which workflows you missed, with a week to fix them before the second window.
And don't plan around the date moving again. It moved once, from November 2 to December 2. That's a reason to be glad of the extra month, not to assume there's another one coming.
Find what depends on the trigger
GitHub's preparation step is to use Insights to see which workflow runs the rule would block. Do that first. It's the authoritative list, because it's built from runs that actually happened.
Then do the cheap second check yourself. Search every public repository's workflow files for the string pull_request_target. It turns up in two syntaxes, the list form on: [push, pull_request_target] and the mapping form on: with pull_request_target: as a key, and a plain text search catches both.
Our finding: we ran that search across our own repositories before writing this. FinOpsAid has three workflow files, and none of them uses
pull_request_target. They trigger onpush,pull_requestandworkflow_dispatch. That took one command. The lesson isn't that we're safe, which is a small claim about three files. It's that the two checks answer different questions. A search only sees repositories you've cloned and workflows that exist today. Insights only sees triggers that actually fired during the evaluation period. A workflow that runs on a rare event can be missing from Insights, and a repository nobody on your team has checked out is missing from the search. Use both before November 9, and you'll have caught both kinds of miss.
Allow narrowly, or fix the workflow
GitHub offers two options for each workflow it finds. You can keep the default rule and let pull_request_target be blocked. Or you can explicitly allow it in an applicable Actions event policy, using workflow file targeting to allow specific workflows (GitHub Docs, Control workflow execution).
That second option is per workflow on purpose. A blanket allow reopens exactly what the default closes, for every workflow, including the ones nobody remembers writing. If you need an allow, name the file.
Before you allow anything, ask whether the workflow needs pull_request_target at all. Most uses fall into one of two groups, and only one of them needs it.
Doesn't need it. Building, testing or linting the contributor's code. That's what pull_request is for. It runs fork code without your secrets, which is the safe default for untrusted input. This is our general guidance, not part of GitHub's announcement, but it's the long-standing pattern.
Might need it. Labelling, commenting on or triaging pull requests from forks, which needs a write token. Even then, there's a well-worn safer shape. Run the untrusted part under pull_request and upload its results as an artifact. Do the privileged part in a separate workflow triggered by workflow_run, one that reads the artifact as data and never checks out or executes the PR's code.
If a workflow genuinely stays on pull_request_target and earns an allow, hold it to three rules:
- Never check out the PR head. Running
actions/checkoutagainst the fork's ref insidepull_request_targetis the pattern behind most of the incidents this change is meant to stop. - Set
permissions:explicitly and minimally. Grant only the scopes the job uses, at the job level. - Keep secrets out of reach of anything the contributor controls, including their branch name, PR title and body. Treat those as untrusted input too.
The cost question, answered honestly
This isn't a minutes-cost story, and it'd be dishonest to dress it up as one. Standard GitHub-hosted runners are free for public repositories, and a blocked run doesn't execute at all. Nobody's Actions bill moves because of December 2. The hidden costs in Actions are almost all in private repositories.
The cost is operational. Every blocked attempt during a brownout is a failed run. If your CI dashboards, failure-rate alerts or required checks treat a failed run as a regression, expect a burst of false alarms for two hours on each brownout Monday, and permanently from December 2 for any workflow you leave unhandled. A failure-rate chart that spikes for a reason unrelated to your code teaches people to ignore it. That's the expensive part.
So annotate the brownout windows in whatever tracks CI health. And if a check that used to run under pull_request_target is a required status check, decide now what replaces it. A blocked required check can stop merges in a public repo cold.
What to do this week
- Open Insights and list the runs the rule would block. It's GitHub's own step, and the fastest authoritative answer.
- Search every public repo's workflows for
pull_request_target. It catches what Insights hasn't seen fire yet. - Move build-and-test workflows to
pull_request. No allow needed, and fork code never sees a secret. - Split privileged follow-up into
pull_request+workflow_run. The privileged half reads artifacts and never runs PR code. - Allow the remainder by workflow file, not blanket. Each allow should name a file and have an owner who can say why.
- Mark November 9 and 16, 16:00–18:00 UTC, in your CI monitoring. Then a failed run in that window reads as expected rather than as an incident.
- Check required status checks. Anything that ran under
pull_request_targetand gates merges needs a replacement before December 2.
Where FinOpsAid fits
FinOpsAid is a read-only GitHub App with a nightly sync. It reads workflow runs and the billable time GitHub reports for each one, so a blocked brownout run would appear in our data as a failed run. What it can't do is tell you why a run failed, or which workflows use pull_request_target. For that, use GitHub's Insights and the search above. It's the same position as our GitHub App token audit: a platform change that's worth five minutes of checking, whatever tools you use. For the rest of the recent Actions changes, see three September Actions changes that affect spend tracking.
Frequently asked questions
When does GitHub block pull_request_target by default?
Permanent enforcement starts December 2, 2026, in all public repositories on GitHub Free, Team and Enterprise Cloud. It was previously scheduled for November 2. Two brownouts come first, on November 9 and November 16, 2026, from 16:00 to 18:00 UTC. During them, affected runs fail with an error annotation instead of executing.
Are private repositories affected by the pull_request_target block?
No. GitHub says private and internal repositories aren't affected, and neither is GitHub Enterprise Server. The default rule applies to public repositories only. It blocks pull_request_target there unless an applicable Actions event policy explicitly allows it, which you can scope to specific workflows using workflow file targeting.
How do I keep a workflow that needs pull_request_target working?
Explicitly allow it in an applicable Actions event policy, using workflow file targeting to name that workflow rather than allowing the trigger everywhere. First check whether it needs the trigger at all. Build and test jobs belong on pull_request. Privileged follow-up can usually move to a separate workflow_run workflow that never runs PR code.
Sources
- GitHub, "pull_request_target blocked by default December 2", retrieved 2026-11-03, https://github.blog/changelog/2026-11-02-pull_request_target-blocked-by-default-december-2
- GitHub Docs, "Control workflow execution", retrieved 2026-11-03, https://docs.github.com/actions/how-tos/administer/control-workflow-execution
If you want to see failed and billable runs across every repository in one place before the brownouts, connect your GitHub org — read-only and free during beta — or explore the demo dashboard first.