Cloning a remote Git repository is the first real step in most collaborative development workflows. If you need a local copy of shared code, git clone is the command that brings down the repository history, branches, tags, and remote connection so you can start working right away.
Quick Answer
git clone creates a full local copy of a remote Git repository, including commit history, branches, tags, and the origin remote. As of 2026, it is the standard way to start working from an existing project because it preserves history and sets up remote tracking automatically, unlike manually copying files or starting with git init.
Quick Procedure
- Copy the repository URL from the hosting platform.
- Run
git clone <repository-url>in your terminal. - Choose HTTPS or SSH based on your access method.
- Change into the new project folder and check
git remote -v. - Confirm the default branch and recent commit history.
- Switch branches only if your team workflow requires it.
- Fix URL, access, or credential problems before you start coding.
| Primary Command | git clone <repository-url> |
|---|---|
| Default Output | Creates a new local repository folder as of October 2026 |
| Remote Name | origin is configured automatically as of October 2026 |
| Common Protocols | HTTPS and SSH as of October 2026 |
| Typical Use | Start work on an existing project with history and branches as of October 2026 |
| Advanced Options | --depth, --branch, and --single-branch as of October 2026 |
| Best Verification Check | git remote -v and git log --oneline --decorate -5 as of October 2026 |
Introduction
If you need to work on an existing codebase, git clone is usually the first command you run. It copies a remote repository to your workstation and gives you a local project with full history, not just a zip file of source code.
This guide explains what is git clone, how the git clone command works, and when to use common git clone options. You will also see how HTTPS and SSH differ, how to clone into a specific folder, how to handle branches, and how to troubleshoot authentication failures without guessing.
One point causes confusion for beginners and experienced users alike: cloning is not the same as fetching or pulling. Clone creates the repository for the first time, fetch updates remote-tracking references, and pull combines fetch with a merge or rebase on your current branch. That difference matters because each command changes a local repository in a different way.
Cloning is a setup action, not a sync action. If you already have the repository locally, you usually want
git fetchorgit pull, not another clone.
According to the official Git documentation at Git SCM, clone copies an existing repository and initializes your local environment with a remote named origin. For workflow context, GitHub documents clone URL formats and authentication behavior in its own docs at GitHub Docs.
Understanding What Git Clone Actually Does
Git clone is a full repository transfer, not a basic file copy. It brings down tracked file content, all reachable commit history, branch pointers, tags, and the remote configuration needed to keep syncing with the source repository later.
That means the local copy is immediately useful for development. You can inspect history, switch branches, create new commits, and push changes back to the remote if you have permission. In a team environment, the remote repository remains the source of truth, while your clone becomes the working copy where you edit files and stage changes.
What gets copied during a clone
When Git clones a remote repository, it reconstructs the project from objects stored in the remote database. Those objects include commits, trees, and blobs. The commit objects preserve the full history, the tree objects describe directory structure, and the blob objects contain the file contents.
- Commit history so you can inspect previous work and changes over time.
- Branches so you can work from the right line of development.
- Tags so release points remain available locally.
- Remote configuration so future fetch and push operations know where to go.
After cloning, Git usually creates a remote-tracking branch such as origin/main. That branch is not a local working branch you edit directly. It is Git’s record of what the remote branch looked like the last time you fetched from the server.
Why remote-tracking branches matter
Remote-tracking branches help you understand whether your local branch is behind, ahead, or aligned with the remote. For example, if origin/main has new commits, you can fetch and merge them into your local main branch. This is the backbone of most multi-developer workflows.
For a deeper definition of repository structure, see the ITU Online glossary entry for Repository. When you clone a repository, you are not just copying a folder; you are copying versioned project history with remote awareness.
The official Git clone reference at Git SCM explains how the command initializes the local repository and configures the default remote. That behavior is why clone is the standard starting point for shared codebases.
Clone vs Fetch vs Pull: Knowing the Difference
Clone creates a new local repository from a remote source. Fetch downloads new remote data without changing your working files. Pull is fetch plus an update step, usually a merge or rebase, applied to the current branch.
These commands are related, but they are not interchangeable. If you use the wrong one, you can end up with a repository that looks current in name only. That is a common source of confusion during onboarding and when troubleshooting branch behavior.
| Clone | Creates the repository locally for the first time and configures origin. |
|---|---|
| Fetch | Updates remote-tracking references without touching your current branch. |
| Pull | Fetches and then integrates the remote changes into your current branch. |
Use clone when you are starting a new workspace from an existing project. Use fetch when you want to inspect what changed on the remote before deciding what to do. Use pull when you are ready to bring remote changes into your current branch and accept the merge or rebase result.
A practical example: if a teammate pushed ten commits to origin/main, running git fetch lets you review those commits before you integrate them. Running git pull updates your local branch immediately. Running git clone again would create a second copy of the same repository, which is usually unnecessary.
For command behavior and branch references, the official Git documentation at Git fetch and Git pull provides the clearest baseline. That documentation matters because the difference between the commands is behavioral, not cosmetic.
When Cloning Is the Right Choice
Cloning is the right choice whenever you need a complete local copy of an existing project. If the repository already has history, branches, tags, and active contributors, cloning preserves the structure instead of flattening it into plain files.
This is especially important for onboarding. A new developer can clone the project, inspect the branch structure, read commit history, and start contributing with the same context the rest of the team uses. Cloning is also the normal path for open source contributions, bug fixes, hotfix validation, and setting up a new workstation.
Clone instead of git init when history matters
git init creates a new, empty repository. It does not bring in the remote project’s history, tags, or branch structure. If you need those things, cloning is the correct choice because it preserves the full development timeline.
- Use clone for existing code with history and collaborators.
- Use git init for brand-new local projects that have never been versioned.
- Use clone when you need the remote source of truth locally.
In a team setting, cloning prevents accidental divergence. Everyone starts from the same repository state, sees the same branches, and can verify the same tags or release points. That consistency is one reason remote Git workflows scale so well across distributed teams.
For workflow terminology, the glossary definition of Onboarding is relevant because clone is often the first technical step in getting a new developer productive. The better your clone instructions are, the less time people waste figuring out environment setup.
How Do You Use the Standard Git Clone Command?
The standard command is simple: git clone <repository-url>. If you paste a valid repository URL, Git creates a new local folder, initializes the repository, downloads the objects, and configures the remote connection automatically.
By default, Git names the new folder after the repository name. If the remote is https://github.com/example/project.git, the local folder is typically named project. You can override that behavior by adding a destination directory name at the end of the command.
Basic clone example
Here is a simple example using an HTTPS URL:
git clone https://github.com/example/project.git
After the command finishes, move into the project folder and inspect the result:
cd project
git remote -v
git branch -a
The remote named origin is created automatically. That remote becomes the default target for fetch and push operations unless you reconfigure it later. This is why most developers can clone and start working in a matter of seconds.
If you need official guidance on repository URLs and hosting behavior, GitHub’s documentation at GitHub Docs and GitLab’s docs at GitLab Docs are good references. The exact URL format changes by host, but the clone workflow stays consistent.
Choosing Between HTTPS and SSH
HTTPS and SSH are the two most common clone protocols. HTTPS is usually easier for first-time setup, while SSH is often better for developers who interact with Git several times a day and want passwordless authentication after key setup.
With HTTPS, authentication typically relies on a username plus a personal access token rather than a raw password. With SSH, authentication uses a private key on your workstation and a public key added to the hosting platform. Both can be secure when configured properly.
| HTTPS | Best for simple setup, browser-based credential flows, and occasional contributors. |
|---|---|
| SSH | Best for frequent Git use, automation, and environments where keys are already managed. |
Use HTTPS if your organization manages access through tokens, single sign-on, or a browser-first login flow. Use SSH if your team expects key-based access, you work across multiple repositories daily, or you need a smoother experience in shells and automation scripts.
Protocol choice affects authentication
Authentication is one of the main reasons clone fails. A URL can be correct and still fail if your account lacks access or your token has expired. For private repositories, that is normal behavior rather than a Git bug. The hosting platform is enforcing permissions.
For credential guidance, the official Microsoft Learn documentation on Microsoft Learn and vendor docs from GitHub are good examples of how modern access flows work. If you are using a Git host that supports SSH, the host’s own documentation should be the source of truth for key setup.
Pro Tip
If you expect to work on multiple private repositories, set up SSH keys once and test them before you start cloning. That prevents repeated token prompts and reduces setup friction on every new project.
How Do You Clone Into a Specific Folder?
You can clone into a specific folder by adding the target directory name after the repository URL. This is useful when the default folder name is too generic, when you want a predictable workspace layout, or when you need to avoid naming conflicts.
The syntax is straightforward:
git clone https://github.com/example/project.git workspace/project-a
In that example, Git still clones the same repository, but it stores the local copy in workspace/project-a instead of creating a folder named after the remote repository. That is helpful when you manage multiple similarly named projects or follow a company-standard workspace structure.
Why destination folders matter
Folder names affect more than convenience. Build scripts, editor settings, and onboarding instructions often assume a predictable directory structure. If your team documentation says, “clone into ~/work/apps/project-a,” every developer gets a cleaner and more repeatable setup.
- Use a custom folder when the repository name is too generic.
- Use a nested workspace path when you manage multiple projects.
- Use a consistent naming convention to reduce confusion in onboarding docs.
There is a small but important difference between the remote repository name and your local directory name. The clone operation links the local working copy to the remote source regardless of the folder name you choose. The folder is just the local container for the cloned repository.
If you are organizing files on your Workstation, consistent directory naming saves time later. It is easier to remember where projects live, and easier to automate tasks with scripts and shell aliases.
Working With Branches After Cloning
After cloning, Git usually checks out the repository’s default branch, often main or sometimes master. That means your working tree reflects the branch the project maintainer configured as the primary line of development.
You can inspect all branches that came down with the clone using git branch -a. That command shows both local branches and remote-tracking branches, which helps you see what is available before you switch workstreams.
Switching to another branch
If your team uses feature branches, you may need to check out a branch after cloning. A common workflow looks like this:
git clone https://github.com/example/project.git
cd project
git branch -a
git switch feature/login-fix
If the branch exists only on the remote, create a local tracking branch from it:
git switch --track origin/feature/login-fix
Local branches are branches you actively work on. Remote-tracking branches are read-only references to what the remote looked like the last time you fetched. That difference matters when you are reviewing code, preparing a pull request, or deciding where to commit.
Git’s branch and checkout behavior is documented in the official Git reference at Git switch. If your team uses branch protection or review gates, those rules are usually defined by the hosting platform rather than Git itself.
What Are Shallow Clones and Other Advanced Git Clone Options?
A shallow clone downloads only part of the repository history, usually the most recent commits. That reduces download size and can make initial setup faster, especially for large repositories with years of history.
The most common syntax is:
git clone --depth 1 https://github.com/example/project.git
This command is useful when you only need the current state of the code, such as for a build job, temporary test environment, or quick inspection. The tradeoff is that older history is missing or limited, which can make debugging and deep history analysis harder later.
Other useful clone options
--branch <name>clones and checks out a specific branch.--single-branchlimits the clone to one branch’s history.--mirrorcreates a mirror clone, which is usually used for repository replication or administrative tasks.
A mirror clone is not the same thing as a normal working clone. It is designed for exact replication of refs, not daily development. If you need a standard developer checkout, use normal clone behavior or one of the targeted options above, not mirror mode.
Git documents these behaviors in the official clone reference at Git SCM. The right option depends on workflow, not just speed. If you need history for debugging, do not cut it away just to save bandwidth.
Warning
Shallow clones can break later assumptions. If your team expects full history for version comparison, release tagging, or diagnosing old bugs, a limited clone may create more problems than it solves.
How Do Authentication and Permission Problems Break Clones?
Clone failures usually come from URL mistakes, missing permissions, expired credentials, or SSH key problems. The command itself is often fine. The access path is what fails.
For private repositories, the repository may exist and the URL may be accurate, but your account still might not have permission to read it. That is especially common in organizations that rotate tokens, enforce single sign-on, or restrict repository visibility by team membership.
Common clone failure causes
- Incorrect URL such as a typo, missing path segment, or wrong host.
- Wrong protocol when the team expects HTTPS but you used SSH, or vice versa.
- Expired token when HTTPS credentials are no longer valid.
- Missing SSH key or a public key that was never added to the hosting platform.
- Insufficient repository permission on private or restricted projects.
A practical troubleshooting sequence is simple: verify the URL, confirm access rights, check your credential or key setup, and try again. If the repository belongs to a hosted platform like GitHub or GitLab, check the account settings and repository permissions in the platform UI before assuming Git is broken.
For background on identity and access concepts, the glossary definition of Authentication is useful here. Authentication proves who you are; authorization determines what you are allowed to do.
If you want vendor-specific guidance on access and credential flows, the hosting platform’s official documentation is the right place to start. GitHub’s documentation at GitHub Docs and GitLab’s documentation at GitLab Docs both cover the mechanics of private repository access clearly.
How Do You Verify That the Clone Worked?
A successful clone should give you a local repository, a clean checkout of the default branch, and a valid remote named origin. The quickest way to confirm that is to check the remote, inspect the branch list, and review recent history.
Run these commands after cloning:
cd project
git remote -v
git branch -a
git log --oneline --decorate -5
git status
What success looks like
git remote -vshows the expected repository URL for fetch and push.git branch -ashows the default branch and available remote-tracking branches.git logshows recent commits instead of an empty history.git statusreports a clean working tree unless you changed files.
Verification matters because clone problems are not always obvious at first glance. A repository can appear to exist locally while actually pointing to the wrong remote, missing history, or checking out a different branch than expected. Catching that early saves time later when you try to push, merge, or build.
If you want a general source for Git behavior, the official reference at Git SCM Documentation is the most direct resource. That is the baseline you should trust when a local result does not match what you expected.
What Common Mistakes Should You Avoid When Cloning?
The most common mistake is cloning the wrong repository URL. A second common mistake is using the wrong protocol for the way your organization authenticates. Both lead to setup delays that are easy to avoid with a few minutes of checking up front.
Another frequent problem is confusing clone with pull. If you expect git clone to update an existing local repository, you are using the wrong command. Clone is for first-time setup. Pull is for bringing in remote changes after the repository already exists locally.
Other avoidable errors
- Cloning into the wrong folder and creating a confusing directory structure.
- Nesting repositories accidentally when you clone inside another Git working tree.
- Using shallow clones too aggressively and later needing missing history.
- Skipping verification and discovering access problems only after you start working.
It also helps to watch for repository layout issues. If you clone inside a directory that already contains another Git repository, you may confuse your editor, build scripts, or shell prompts. That is especially painful when you manage multiple projects or switch contexts often.
For project structure and directory terminology, the glossary definition of Directory applies directly here. A clean directory layout is not cosmetic; it reduces operational mistakes.
What Does a Practical Team Workflow Look Like?
A typical team workflow starts with copying the repository URL, cloning the project, and verifying the remote. From there, the developer checks out the right branch, reviews commit history, and starts work in a known-good local state.
For a bug fix, a developer may clone the repository, switch to a release branch, create a fix branch, and then open a pull request. For exploratory work, the developer may clone the main branch, inspect the codebase, and create a new branch only after identifying the change needed. The clone step is the same; the follow-up work depends on the task.
How teams make clone smoother
Strong team documentation prevents repeat questions. A good repository setup guide usually includes the exact clone URL, expected folder name, branch conventions, and any authentication requirements before a new developer starts.
- Copy the repository URL from the approved source.
- Clone into the documented workspace path.
- Verify
originand the default branch. - Switch to the required branch if the team uses one.
- Run the project’s build or test command to confirm the local setup.
That sequence is simple, but it prevents a lot of churn. Teams that standardize clone instructions reduce onboarding time, cut down on avoidable errors, and make local environments more predictable. Good Git hygiene starts before the first commit.
For broader context on shared-code practices, the official GitHub Git Guides are a useful reference point because they reinforce standard repository behavior without relying on third-party tooling advice. That keeps the workflow grounded in the platform developers actually use.
Key Takeaway
git clone creates a full local repository, not just a copy of files.
HTTPS is usually simpler for first-time setup, while SSH is often better for frequent contributors.
Clone starts a repository, fetch updates remote references, and pull integrates remote changes into your current branch.
Shallow clones save time, but they limit history and can complicate later troubleshooting.
Verification with git remote -v, git branch -a, and git log catches mistakes early.
Conclusion
Cloning a remote Git repository gives you a complete local copy of the project plus a live connection back to the source. That combination is what makes Git workflows practical for teams, open source contributors, and developers setting up a new workstation.
Now you know how to choose between HTTPS and SSH, how to clone into a specific folder, how to handle branches after cloning, and how to use advanced git clone options without creating avoidable problems. You also know why clone is different from fetch and pull, and why that difference matters every time you work with shared code.
Before you move on, verify the remote URL, confirm the default branch, and check your history. If clone fails, troubleshoot access methodically: URL, permission, credentials, then retry. That habit saves time and prevents messy setup problems later.
Mastering git clone is not a minor Git skill. It is the foundation for every clean, repeatable repository workflow you will use after that first command.
Git is a trademark of Software Freedom Conservancy, Inc.
