What is the difference between git pull and git fetch?

git fetch downloads new commits from the remote repository without merging them into your local branch. git pull does the same but automatically merges (it's a fetch + merge). Fetch is more cautious as it lets you see the changes before integrating them.

Can git pull create conflicts?

Yes, because git pull merges automatically. If remote changes conflict with your local changes, you'll need to resolve the conflicts. With fetch, you can anticipate these conflicts before merging.

What is git pull --rebase?

git pull --rebase does a fetch then a rebase (instead of a merge). This places your local commits after the remote commits, creating a linear history. It's often preferred in teams to avoid unnecessary merge commits.

Should I always fetch before pulling?

No, it's not necessary because pull already includes fetch. But it's a good habit to fetch first when working on sensitive branches or when you want to anticipate potential conflicts.

Git pull vs fetch: what is the difference?

Two commands to retrieve remote code, but very different behavior. This page explains when to use git pull and when to prefer git fetch.

Practice pull and fetch Git glossary

gitquest — enquête

The difference at a glance

`git fetch`

Downloads new commits from the remote repository without modifying your local branch. It's like looking at updates before integrating them.

Formula: fetch = download

`git pull`

Downloads new commits and merges them automatically into your local branch. It's a shortcut: fetch + merge in one command.

Formula: pull = fetch + merge

In practice in the terminal

Here is how fetch and pull behave concretely.

git fetch (cautious)

gitquest — fetch

# git fetch: download without merging

$git fetch origin

remote: Counting objects: 5, done.

From github.com:team/project

a1b2c3d..f4e5d6c main -> origin/main

# Changes are downloaded but NOT merged

$git log --oneline main..origin/main

f4e5d6c Fix bug #42

c3d4e5f Add unit tests

# You can review the changes before integrating

$git merge origin/main

Updating a1b2c3d..f4e5d6c (fast-forward)

git pull (direct)

gitquest — pull

# git pull: fetch + merge in a single command

$git pull origin main

remote: Counting objects: 5, done.

From github.com:team/project

a1b2c3d..f4e5d6c main -> origin/main

Updating a1b2c3d..f4e5d6c

Fast-forward

src/index.html | 5 ++++

tests/test.js | 12 +++++++++

2 files changed, 17 insertions(+)

When to use one or the other

Use `git fetch` when:

You want to see the changes before integrating them

You're working on a complex branch and want to avoid surprises

You want to compare your local changes with the remote

You want to choose between merge or rebase after seeing the changes

Use `git pull` when:

You're on a main branch with no local work in progress

You simply want to get up to date quickly

You know there won't be conflicts with your work

You prefer speed over caution

Advanced tip

The best option: `git pull --rebase`

Many experienced developers prefer git pull --rebase. This variant does a fetch then a rebase instead of a merge.

Advantage

Creates a linear history, without unnecessary merge commits. The log is more readable and code reviews are simpler.

How to enable it by default

git config --global pull.rebase true

All your future git pull commands will rebase automatically.

GitQuest is created by Anaïs (nouvelle fenêtre), web developer and head of education, specializing in tech training and digital accessibility.

Questions about pull and fetch

Practice pull and fetch in a safe terminal

GitQuest investigations put you in real-world teamwork situations with remote repositories.

Start the investigations