How Can I Check out a Github Pull Request with Git?

This will fetch without you having to name a branch:

git pull origin pull/939/head

How do I get a specific pull request on my machine?

I prefer to fetch and checkout without creating a local branch and to be in HEAD detached state. It allows me quickly to check the pull request without polluting my local machine with unnecessary local branches.

git fetch upstream pull/ID/head && git checkout FETCH_HEAD

where ID is a pull request ID and upstream where is original pull request has been created (it could be origin, for example).

I hope it helps.

That gist does describe what happend when you do a git fetch:

Obviously, change the github url to match your project's URL. It ends up looking like this:

[remote "origin"]
    fetch = +refs/heads/*:refs/remotes/origin/*
    url = :joyent/node.git
    fetch = +refs/pull/*/head:refs/remotes/origin/pr/*

Now fetch all the pull requests:

$ git fetch origin
From github.com:joyent/node
 * [new ref]         refs/pull/1000/head -> origin/pr/1000
 * [new ref]         refs/pull/1002/head -> origin/pr/1002
 * [new ref]         refs/pull/1004/head -> origin/pr/1004
 * [new ref]         refs/pull/1009/head -> origin/pr/1009
...

To check out a particular pull request:

$ git checkout pr/999
Branch pr/999 set up to track remote branch pr/999 from origin.
Switched to a new branch 'pr/999'

You have various scripts listed in issues 259 to automate that task.
The git-extras project proposes the command git-pr (implemented in PR 262)

git-pr(1) -- Checks out a pull request locally

SYNOPSIS

git-pr <number> [<remote>]
git-pr clean

DESCRIPTION

Creates a local branch based on a GitHub pull request number, and switch to that branch afterwards.

The name of the remote to fetch from. Defaults to origin.

EXAMPLES

This checks out the pull request 226 from origin:

$ git pr 226

remote: Counting objects: 12, done.
remote: Compressing objects: 100% (9/9), done.
remote: Total 12 (delta 3), reused 9 (delta 3)
Unpacking objects: 100% (12/12), done.
From 
  * [new ref] refs/pull/226/head -> pr/226
Switched to branch 'pr/226'

Github recently released a cli utility called github-cli. After installing it, you can checkout a pull request's branch locally by using its id (doc)

e.g: gh pr checkout 2267

This works with forks as well but if you then need to push back to the fork, you'll need to add the remote repository and use traditional git push (until this ticket gets implemented in gh utility)

If you are using Github.com, go to "Pull requests", click on the relevant pull request, and then click on the "command line instructions" link:

Referencing Steven Penny's answer, it's best to create a test branch and test the PR. So here's what you would do.

1. Create a test branch to merge the PR into locally. Assuming you're on the master branch:

git checkout -b test

2. Get the PR changes into the test branch

git pull origin pull/939/head:test

Now, you can safely test the changes on this local test branch (in this case, named test) and once you're satisfied, can merge it as usual from GitHub.

The problem with some of options above, is that if someone pushes more commits to the PR after opening the PR, they won't give you the most updated version. For me what worked best is - go to the PR, and press 'Commits', scroll to the bottom to see the most recent commit hash and then simply use git checkout, i.e.

git checkout <commit number>

in the above example

git checkout 0ba1a50

You can use git config command to write a new rule to .git/config to fetch pull requests from the repository:

$ git config --local --add remote.origin.fetch '+refs/pull/*/head:refs/remotes/origin/pr/*'

And then just:

$ git fetch origin
Fetching origin
remote: Counting objects: 4, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 4 (delta 2), reused 4 (delta 2), pack-reused 0
Unpacking objects: 100% (4/4), done.
From 
 * [new ref]         refs/pull/2/head -> origin/pr/2
 * [new ref]         refs/pull/3/head -> origin/pr/3

For Bitbucket, you need replace the word pull to pull-requests.

First, you can confirm the pull request URL style by git ls-remote origin command.

$ git ls-remote origin |grep pull
f3f40f2ca9509368c959b0b13729dc0ae2fbf2ae    refs/pull-requests/1503/from
da4666bd91eabcc6f2c214e0bbd99d543d94767e    refs/pull-requests/1503/merge
...

As you can see, it is refs/pull-requests/1503/from instead of refs/pull/1503/from

Then you can use the commands of any of the answers.

If you're following the "github fork" workflow, where you create a fork and add the remote upstream repo:

14:47 $ git remote -v
origin  :<yourname>/<repo_name>.git (fetch)
origin  :<yourname>/<repo_name>.git (push)
upstream        :<repo_owrer>/<repo_name>.git (fetch)
upstream        :<repo_owner>/<repo_name>.git (push)

to pull into your current branch your command would look like:

git pull upstream pull/<pull_request_number>/head

to pull into a new branch the code would look like:

git fetch upstream pull/<pull_request_number>/head:newbranch

I'm using hub, a tool from github:

With hub checking out a pull request locally is kinda easy:

hub checkout 
or
hub pr checkout 1234

I accidentally ended up writing almost the same as provided by git-extras. So if you prefer a single custom command instead of installing a bunch of other extra commands, just place this git-pr file somewhere in your $PATH and then you can just write:

git pr 42
// or
git pr upstream 42
// or
git pr 

Get the remote PR branch into local branch:

git fetch origin ‘remote_branch’:‘local_branch_name’

Set the upstream of local branch to remote branch.

git branch --set-upstream-to=origin/PR_Branch_Name local_branch

When you want to push the local changes to PR branch again

git push origin HEAD:remote_PR_Branch_name

With newer versions of Git:

git fetch origin refs/pull-requests/<id>/from:<localbranchname>

Suppose your origin and upstream info is like below

   $ git remote -v
   origin  :<yourname>/<repo_name>.git (fetch)
   origin  :<yourname>/<repo_name>.git (push)
   upstream   :<repo_owner>/<repo_name>.git (fetch)
   upstream   :<repo_owner>/<repo_name>.git (push)

and your branch name is like

   <repo_owner>:<BranchName>

then

   git pull origin <BranchName>

shall do the job

To quickly check PR on your local, open it and check the branch name from which PR is created.

As we can see in the red line above name of branch is 'CLUPET-173-glrr-apis' use below command to quickly see the code in the PR/Branch

git checkout origin/CLUPET-173-glrr-apis

Now this code on your local would run as detached head mode.

To stop all PR code viewing and to go back to your previous branch

git switch -

In case you want to move PR(plus any new local changes you made after fetching PR) to a new local branch use below command

git switch -c myNewLocalBranch

To checkout PR and see all changes from that PR as compared to the main branch in VSCode. Similar to files changed section of Github PR page.

1. checkout PR (100) in 'detached HEAD' state
   git fetch origin pull/100/head && git checkout FETCH_HEAD

2. show as uncommitted changes
   git reset main

3. switch back to main branch and carry these changes
   git switch -

Although most of the answers on this thread work, I prefer cherry-picking the pull request changes, this allows me to test as well as see the difference in my IDE.

git checkout <newbranch>
git fetch origin pull/<pullrequestId>/head && git cherry-pick FETCH_HEAD

e.g

git checkout test-pr
git fetch origin pull/34/head && git cherry-pick FETCH_HEAD

Running the above command will pull the changes of the PR and show them in your IDE version control since those changes won't be committed.

There is an easy way for doing this using git-cli

gh pr checkout {<number> | <url> | <branch>}

Reference:

Create a local branch

git checkout -b local-branch-name

Pull the remote PR

git pull :your-repo-ssh.git remote-branch-name