Introduction

The standard way to answer this question is to inspect the current remote URL, usually the one named origin. The important nuance is that Git does not store a separate permanent field called “original clone URL”, so if someone later changes the remote, the original source may already be lost.

That means there are really two questions here: what URL does this repository currently point to, and is that still the same URL it was cloned from? Git can answer the first one directly. The second one is only answerable if the remote configuration has not been changed or if you have external evidence.

Check The Current origin Remote

In the common case, this is the fastest command:

git remote get-url origin

If the repository was cloned normally and nobody modified the remote definition, this output is effectively the clone URL.

You can also inspect all remotes at once:

git remote -v

Typical output looks like this:

1origin  [email protected]:example/project.git (fetch)
2origin  [email protected]:example/project.git (push)
3upstream  https://github.com/parent/project.git (fetch)
4upstream  https://github.com/parent/project.git (push)

That is useful when the repository has both origin and upstream, or when the default remote is not named origin.

Read The Stored Value From Git Config

Remote URLs live in the repository config. You can query the exact stored value with:

git config --get remote.origin.url

That corresponds to a section inside .git/config such as:

[remote "origin"]
    url = [email protected]:example/project.git
    fetch = +refs/heads/*:refs/remotes/origin/*

Reading config directly is helpful in scripts, debugging sessions, or cases where you want one specific value instead of the formatted output from git remote -v.

The Big Limitation

Many short answers stop at git remote -v, but that only tells you the current remote configuration. Git does not maintain a special historical record that says this repository was originally cloned from some earlier URL.

For example, if someone runs this command later:

git remote set-url origin [email protected]:new-owner/project.git

then git remote get-url origin will report the new location, not the old one. The previous value is overwritten in the normal config.

What To Do If The Remote Was Changed

If you suspect the repository used to point somewhere else, you have to look outside the standard Git remote metadata. Useful places to check include:

• terminal shell history on the machine where git clone was run
• backups or earlier copies of .git/config
• CI logs or onboarding documentation
• team records for repository migrations or fork changes

People sometimes expect git reflog to help here, but reflog tracks branch tip movements, not a guaranteed historical record of the original clone source.

Repositories Without origin

Not every repository has an origin remote. A project might have been created with git init, the remote could have been removed, or the team may use another name.

Start by listing remote names:

git remote

Then inspect whichever remote exists:

git remote get-url upstream

If there are no remotes at all, Git has no stored clone URL to show you.

A Practical Multi-Remote Check

When you want a compact overview of every configured remote, a shell loop is useful:

git remote | while read remote_name; do
  printf "%s -> %s\n" "$remote_name" "$(git remote get-url "$remote_name")"
done

This is helpful in repositories with fork-based workflows, mirrored remotes, or unusual naming conventions.

Common Pitfalls

• Assuming Git stores the original clone URL separately from the current remote URL.
• Looking only for origin when the repository uses a different remote name.
• Forgetting that git remote set-url overwrites what Git will report later.
• Expecting reflog to preserve clone-source metadata.
• Confusing the current push target with historical provenance.

Summary

• Use git remote get-url origin to see the current origin URL.
• Use git remote -v or git remote to inspect all configured remotes.
• The stored remote URL lives in .git/config and can be queried with git config --get.
• Git usually shows the current remote, not a guaranteed historical original.
• If the remote changed, recovering the true original clone source requires external evidence.