Anatomy of a URL

You type a web address, hit Enter, and a page appears. It feels like magic, but that address is actually a tidy little instruction packed with meaning. Every character has a job. Once you can read a URL the way a browser does, the web stops feeling mysterious and starts feeling like something you can reason about.

In this article we’ll take one ordinary link apart, piece by piece. We’ll use friendly examples like example.com and acy-partner.com, and by the end you’ll be able to glance at any address and know exactly what each part is telling the browser to do.

What “URL” actually means

URL stands for Uniform Resource Locator. Strip away the jargon and it simply means “a standard way to point at a thing on the internet.” That “thing” is called a resource — usually a web page, but it can also be an image, a video, a file, or data returned by a program.

The word uniform is the important one. Because everyone agrees on the same format, your browser, a search engine, and a server on the other side of the planet all read an address the same way. No guessing required.

Here is the full shape of a URL, with every optional part included:

scheme://host:port/path?query#fragment

Most everyday links don’t show all of these. Many parts are optional, and browsers quietly fill in sensible defaults when you leave them out. Let’s walk through each one.

The labeled example

Before we dig in, here’s a single address with every part labeled. Keep this picture in mind as we go.

 https://www.acy-partner.com:443/blog/post?id=5#summary
 └─┬─┘   └──────┬─────────┘ └┬┘ └───┬────┘ └─┬──┘ └─┬───┘
 scheme       host          port   path     query  fragment

Read left to right, the browser asks itself: How should I connect (scheme), who do I talk to (host), which door do I knock on (port), what do I want (path), with what extra details (query), and where on the page should I land (fragment).

Scheme: how to connect

The scheme comes first, before the ://. It tells the browser which set of rules — which protocol — to use for the conversation.

https://...
└─┬─┘
scheme

The two you’ll see most are:

There are other schemes too — mailto: opens an email draft, ftp: is for file transfer, tel: starts a phone call on mobile — but for browsing the web, https is what you want.

Notice the :// right after the scheme. The colon ends the scheme, and the two slashes signal that a host name is coming next. It’s just punctuation that separates one part from another.

Host: who you’re talking to

The host is the address of the machine you want to reach. It usually looks like a domain name you can read, such as www.acy-partner.com.

https://www.acy-partner.com/...
        └────────┬────────┘
              host

A domain name is actually built from smaller pieces, read from right to left:

www  .  acy-partner  .  com
 │          │           │
subdomain   name       top-level domain (TLD)

• com is the top-level domain (TLD). Others include org, net, and country codes like id for Indonesia.
• acy-partner is the registered name a person or company owns.
• www is a subdomain — a label in front that points to a specific area. www is a tradition for the main website, but you can have others, like blog.acy-partner.com for a blog, all under the same registered name.

Behind the scenes, a friendly domain name has to be translated into a numeric IP address (something like 93.184.216.34) before any connection can happen. That translation is handled by DNS, the internet’s phone book — a topic worth exploring on its own once you’re comfortable here.

Port: which door to knock on

A single server can offer many services at once. The port is a number that says which specific service — which “door” — your request is meant for.

https://www.acy-partner.com:443/...
                           └─┬─┘
                           port

Here’s the good news: you almost never type a port. Each scheme has a default, and the browser fills it in for you.

So https://www.acy-partner.com and https://www.acy-partner.com:443 mean exactly the same thing. You’ll mostly see explicit ports in development, for example http://localhost:3000, where a local server is running on a non-standard door.

Path: what you want

After the host (and optional port) comes the path — everything from the first / onward, up to a ? or #. The path points to a specific resource on that server, much like a folder-and-file location.

https://www.acy-partner.com/blog/post
                           └────┬────┘
                              path

A path of just / means the home page — the root of the site. Deeper paths drill into specific sections or pages:

/                     →  home page
/blog                 →  the blog section
/blog/post            →  one specific post
/images/logo.png      →  an image file

Paths are case-sensitive on many servers, so /Blog and /blog can lead to two different places. When in doubt, match the exact capitalization you were given.

Query: the extra details

Sometimes a path alone isn’t enough — you need to pass extra information along with your request, like a search term or which item to show. That’s the job of the query string, which begins with a ?.

https://www.acy-partner.com/blog/post?id=5
                                      └─┬─┘
                                     query

A query is a list of key/value pairs. Each pair is key=value, and multiple pairs are joined with &:

?id=5
?search=dns&page=2
?category=web&sort=newest&page=3

Reading that last one: search within category equal to web, sort by newest, and show page number 3. The server reads these values and decides what to send back. This is how the same page address can show different content — a search results page, for instance, changes entirely based on its query.

Because some characters (spaces, &, =, and others) have special meaning inside a query, they get encoded when they appear as data. A space, for example, often becomes %20 or +. If you ever see odd % codes in a link, that’s just safe encoding at work, not a mistake.

Fragment: where to land on the page

The last optional part is the fragment, introduced by a #. It points to a specific spot within the page that’s already loaded.

https://www.acy-partner.com/blog/post#summary
                                      └───┬───┘
                                     fragment

When a page has a section marked with the id summary, adding #summary tells the browser to scroll straight to it. Those “jump to section” links in a table of contents work exactly this way.

The key thing to understand: the fragment is handled entirely by your browser and is never sent to the server. The server delivers the whole page; the # just decides where you start reading. That’s why changing only the fragment can move you around a page without reloading it.

Putting it all together

Let’s read our full example one more time, now that you know every part:

https://www.acy-partner.com:443/blog/post?id=5#summary

• https — connect securely.
• www.acy-partner.com — to this server.
• :443 — on the standard secure-web door (usually hidden).
• /blog/post — fetch the blog post resource.
• ?id=5 — specifically the one identified by id 5.
• #summary — and scroll me to the summary section once it loads.

That single line is a complete, precise instruction. Read this way, it’s not a string of random characters — it’s a sentence the browser knows how to follow.

Quick reference

Recap and what’s next

A URL only looks intimidating until you know the grammar. There’s a fixed order — scheme, host, port, path, query, fragment — and each part answers one clear question. Most of the time you’ll only see a few of them, because browsers supply sensible defaults for the rest.

The next time an address misbehaves, you’ll have a checklist: Is the scheme https? Is the host spelled correctly? Did a trailing slash sneak in? Is a query value encoded oddly? Reading URLs slowly and on purpose is a small skill that pays off constantly.

A natural next step is to follow the host part deeper — how a name like acy-partner.com gets turned into a real server address through DNS. That’s where the journey from “a link” to “a loaded page” truly begins.