Internet Protocol vs. IP Addresses

The "Fast Lane" Answer

Elsewhere in this delightful series, we have done much pontificating regarding details relevant to this topic. Check them out if you want an expanded view of the electronic cosmos we're building here.

Internet Protocol (or IP) is a series of protocols for running the internet (go figure). It's part of the Internet Protocol suite, and largely consists of a string of instructions and commands that allows devices on the internet to communicate with each other. Think of the internet like a chicken noodle soup: the noodles, vegetables, and meat chunks are the varying kinds of devices linked to the internet. IP is the broth that everything sits in.

That may not have been the best metaphor, but we skipped lunch, so food was on our minds.

IP addresses are part of Internet Protocol, and it's how IP identifies devices that are interconnected. Without a way to know who is who, there would be no way to transfer data from one device to another. So each device is given a "name" in the form of a number as it joins the network or the internet. This is an IP address.

The "Scenic Route" Answer

Internet Protocol

IP is a broad term that's applied to several different limbs of the same beast, so a little bit of dissection will be necessary (sorry for the biology class throwback).

Things that bear the "IP" name:

  • The Internet Protocol suite—the umbrella term under which all intercomputer communications fall; it's a pretty big list
  • Internet Protocol (or just IP)—the primary communication tool used in the suite; it makes up a significant portion of the internet
  • TCP/IP—a shorthand combining both TCP (see below) and IP; it's a common nickname for the IP suite itself.
  • IP Address—a numerical code assigned by IP to devices on the network so that they can be identified for the purposes of transmitting data
  • IPv4/IPv6—versions of the IP address naming system; ironically neither the 4th nor the 6th version of the protocol

The primary focus of this article is separating the IP address from IP itself, and examining each. The only problem is that we're talking about the code that builds the Web, and things get pretty entangled. So we're bound to have a few tangents along the way. Don't worry, we'll crack a joke or two to keep you awake while you read. Just be sure to tip your waiter.

The Suite

The IP suite is immense. It includes everything from high level stuff—like the web browser you're using to read this article—all the way down to the bits and bytes involved in sending information in and out of the local device.

IP is a part or function of the IP suite. It's the number 1 communication protocol, which is why it shares a name with the overall suite. There are alternatives but IP is the standard, excepting only specialized applications. That pretty much means IP is the computer version of things like "Kleenex," "Chlorox," "Xerox," and—hey, how many of these "x"es are there?

Bottom line? The IP suite is the whole thing, while IP is the thing from the overall thing that makes everything work. We're sorry; that's as clear as we can make it.


TCP stands for Transmission Control Protocol, and it's the long-time partner of IP. Imagine the internet is like the postal system. TCP serves as the post offices, where mail is packaged and bundled, prepped and loaded into the truck for transport to another post office or sorting station. The transporters equate to the IP, which handles the actual transfer and delivery of data. All TCP does is break data down into smaller pieces so they'll fit into "packets", so they can be transported more efficiently. Then, at the receiving end of the transmission, TCP reassembles it for the receiving device, just like the post office sorts the incoming mail.

TCP is also a quality control. It waits for missing pieces, requests resubmission of corrupted data, and reassembles all scrambled data, so that it looks the way it did before it was disassembled for transport.

It's really a pretty simple relationship, and here's the 1, 2, 3 on it:

  1. The user (that's you) using a program (say, a web browser) gives the computer a command; something like "Take me to"
  2. The program receives the command, and sends it down various channels, until it lands in the computer's "outbox"
  3. TCP takes the command, breaks it into pieces, puts them in boxes and labels them, even numbering them so the receiver knows what order to unbox them in
  4. TCP hands the packets over to IP, which carries them from connection to connection till it reaches its destination
  5. During transit, IP checks the address of each stop to see if it has arrived yet; it's a real simple "You are Reginald Griffinstein III: if true, package delivered; if false, move to next device and ask again"
  6. You're probably thinking "Going door to door trying to find someone's address would take forever!" and you're right, knocking on doors one at a time would take forever, but computers knock doors a lot faster than we could
  7. IP arrives at destination
  8. IP delivers package to local TCP
  9. TCP checks delivery for corrupt or missing packets; when everything checks out the message is unscrambled and unpacked
  10. The reassembled message is given to the computer's internal processes for final delivery

To sum up, IP is a delivery man, while TCP is the guy who loads the truck.

IP Addresses

Sticking with our oh-so-clever postal metaphor, IP addresses are like, well, addresses. You need one to get any mail. What's more, you need the system to know your address for you to get mail. The postal system can't function anywhere near as effectively if the postman's not sure where the mail is coming from or where it's going. The internet's no different.

So IP labels devices as they come online, assigning them a code that identifies them. Now, there are a couple of things that need clarifying. First, we are in the middle of a transition, switching from one naming system to another. Second, IP addresses can either be "static" or "dynamic", and both have their pros and cons. Third, humans aren't as good about remembering numbers as computers are, but we're pretty good with words and names, so we built a translator. We'll go through each in turn.

IPv4 vs IPv6

This is, well, it's a hearty article on it's own, so if you really want clarification, feel free to peruse the above link. If you think you'll get by with "Yeah, I think I got it", then this level of description should be fine.

IPv4 (stands for "IP version 4", even though it's version 1) is the original system that was put together for identifying devices on a network, back when networking was in it's infancy. It was created during a time when computers couldn't process nearly as much data as they do now, and when there weren't nearly as many computers to network anyway. The "names" it gives to computers are decimal numerals that represent binary values. Each address is four octets (or bytes) of bits.

You know what? There's no way to be brief and be thorough here, so we're going to keep our briefs on and move along. Here's what a few IPv4 address might look like:

Each set of three digits with a max possible value of "255". Why 255? It's part of the whole binary thing we're choosing not to explain here, so just set it aside until you read that article.

With a setup like this (it's called 32-bit by the way, but it won't be on the test), there are somewhere in the neighborhood of 4.3 billion possible addresses that can be assigned. That's a pretty big number; it's more than half the population of the world, so it should last us a while. The guys who put IPv4 together probably thought so too. Boy were we all wrong.

The internet boom of the 1990s changed things, and big-wig computer people started to worry that we would exhaust a number as big as 4 billion. So they started planning, and by 1998 they had something ready that they could start implementing. Then when asked what they should call their creation, they settled on "IP version 6".

Which was silly, since v4 was really v1, and there was never a v5 between them. 4 makes at least a little sense, since there's four bytes in the number. IPv6 doesn't even have that. It's eight sets of four digits, represented with hexadecimal characters. If that made sense, congratulations: you passed the test, and will be awarded the official SmartyStreets' SmartyPants trophy*.

IPv6 is hexadecimal (base 16) which means…it means it's complicated, and there's letters in the numbers, and it's a big number, and when you add everything together it's a 128-bit value (as opposed to the 32-bit value with v4). For comparison and scale, that's 2 to the 32nd power, and 2 to the 128th power, respectively. And if the 32-bit gave us 4.3 billion possible addresses, then, well, 128 bit . . . . We're not going to write the number here, but if you must know, it's in the hundreds of undecillions. Look it up, and be amazed.

Super-basic, what-you-should-know version: IP(not)v4 was in binary(ish), and was too small; IP(not)v6 is in hexadecimal, has letters in the numbers, and is so big even the Hulk can't smash it. Let's move on.

Static vs Dynamic

Okay, this one is waaaaaaaay easier, so relax. Normally, a device often gets a fresh IP address, usually each time it disconnects from the network and reconnects. That's called a "dynamic IP". It's subject to change, and the router determines what you get each time. That's all fine and dandy for most users—doesn't hurt them any if the IP changes on them.

But what about, say, In order to sustain and keep reliable traffic to the site, there has to be a permanent address that doesn't change in the event that the whole system loses power because someone tripped over the power cord or blew a breaker. If it did change, then even if people were punching in the right website name, it wouldn't be directing them to the new IP, which means they would never access the site.

The solution is to drive a nail into the IP, keeping it from wiggling away. That's called a "static IP", and it's what lends the reliability that's required to maintain a public offering on the internet. With static IPs, the router may determine the address, or sometimes it can be chosen by the device. In either case, there's some setup involved, and the result can have some drawbacks (like sometimes doubling up on IP addresses), but at least your mailing address doesn't change each time you leave the house.

You can have the best of both worlds by reserving an IP; that's where a device connects each time as if to receive a dynamic address, but the system has been reserving a specific one for that device, and gives it to the device each time it connects. So the IP never changes, but it's all managed by the network, as opposed to the device.

In the fewest words possible: "dynamic" means "changing"; "static" means "fixed". IP addresses can be either or.

See? Told you it was easier than the numbers-who-should-not-be-named.

IP Address vs DNS

Here's another simple bit (that never gets old). People have a hard time remembering the IP addresses for computers. We're referring to IPv4 when we make this comment; trying to digest IPv6 addresses would just hurt. There's no joke here. Just pain.

Somewhere along the line, somebody got wise and said, "You know what? I'm going to give it a name instead." And the first domain name was born.

DNS stands for Domain Name System, and it's essentially a massive phonebook, connecting the IP addresses of devices and websites to their "domain names". You would most commonly know domain names as website urls. "" is a domain name, and anyone who searches for it is brought first to the DNS phonebook to look up it's IP address mate, then sped on their way to the website.

That's it. We have a whole article about this shtick, but really, the DNS is just a phonebook of names we give to IP addresses so we don't have memorize long strings of alphanumeric characters.

Completing the Circuit

A couple of additional notes that we're just going to toss out there and see if they stick:

  • Not every network uses TCP/IP; there are alternative formats
  • Especially for TCP, which is reliable but sometimes slow
  • The IPv4=>IPv6 switch has already begun, and you're getting those letter-numbers whether you like it or not
  • Static IPs are usually costly, so if you don't need 'em, you don't need 'em
  • Lightsabers are cooler than Phasers; not relevant, but totally applicable

Our support team here at SmartyStreets enjoy talking to people about these kinds of things (even the complicated bits—see, still funny), so feel free to call in. If you stump them, they'll borrow one of our dear friends in the dev team to help explain why hexadecimal insists on being so complicated. Whatever the case, we'd be happy to help by clarifying further what was discussed here.