---
title: "HTTP vs HTTPS: What's the Difference, and Why HTTP Isn't Safe"
url: https://apyhub.com/blog/http-vs-https
author: ApyHub
published: 2026-11-17T10:07:00Z
---

# HTTP vs HTTPS: What's the Difference, and Why HTTP Isn't Safe

## Introduction

**HTTPS is HTTP sent over an encrypted connection.** Both use the same requests, methods and status codes. The difference is that HTTPS wraps them in TLS (Transport Layer Security), which encrypts the data, proves the server is who it claims to be, and detects tampering. Plain HTTP sends everything as readable text.

Think of HTTP as a postcard: anyone who handles it on the way can read it or change it. HTTPS is a sealed, signed envelope: only the recipient can open it, and you can tell if someone tampered with it.

That's why browsers show a padlock for HTTPS and warn about HTTP. Since Chrome 154 (October 2026), Chrome tries HTTPS first and warns you before loading a public site that only works over HTTP.

## HTTP vs HTTPS at a glance

|                    | HTTP                             | HTTPS                                                                                             |
| ------------------ | -------------------------------- | ------------------------------------------------------------------------------------------------- |
| Stands for         | Hypertext Transfer Protocol      | Hypertext Transfer Protocol Secure                                                                |
| Encryption         | None, data is sent as plain text | Encrypted with TLS                                                                                |
| Server identity    | Not verified                     | Verified by a certificate                                                                         |
| Tampering          | Can't be detected                | Detected and rejected                                                                             |
| Default port       | 80                               | 443                                                                                               |
| URL starts with    | http://                          | https://                                                                                          |
| Browser shows      | "Not secure" warning             | Padlock or no warning                                                                             |
| Certificate needed | No                               | Yes, a TLS certificate                                                                            |
| Speed              | No handshake                     | A short TLS handshake on the first connection, and browsers only use HTTP/2 and HTTP/3 over HTTPS |

## Why HTTP isn't safe

With plain HTTP, anyone between you and the server can read and change the traffic. That includes the Wi-Fi network in a café, your internet provider, or a compromised router.

They can see:

* passwords and form data you submit
* cookies, which can be used to take over your session
* API keys and tokens sent in headers
* every page and file you load

They can also change what you receive: inject ads or scripts, swap a download for malware, or redirect a form to their own server. HTTPS blocks both reading and changing, because the data is encrypted and any change breaks the check.

## How HTTPS works

When you open an HTTPS site, your browser and the server do a short TLS handshake before any data is sent:

1. **The server shows its certificate.** It's issued by a certificate authority (CA) and says "this key belongs to apyhub.com".
2. **The browser checks it.** Is it signed by a CA the browser trusts? Is it for this domain? Has it expired?
3. **They agree on encryption keys.** Both sides create a shared secret that nobody watching can work out.
4. **Normal HTTP starts, encrypted.** The same `GET` and `POST` requests and the same status codes, inside the encrypted connection.

You'll still hear "SSL" for this. SSL was the predecessor of TLS and is no longer used, but "SSL certificate" stuck as the everyday name.

## HTTP vs HTTPS proxies

A proxy sits between you and the website. An HTTP proxy forwards plain HTTP requests and can read and change them, the same way anyone on the network can. For HTTPS sites, a normal proxy opens a tunnel (with the `CONNECT` method) and passes the encrypted traffic through without being able to read it. An "HTTPS proxy" usually means the connection between you and the proxy is encrypted too, so the network can't see which sites you ask it for.

## What a real certificate looks like

We checked the certificate for apyhub.com with the SSL Certificate Details endpoint on ApyHub:

```bash
curl "https://api.eu.apyhub.com/tlderscom/domain-pricing-tld-registrar-information/domain/apyhub.com/ssl" \
  -H "apy-token: $APY_TOKEN"
```

```json
{
  "data": {
    "domain": "apyhub.com",
    "valid": true,
    "issuer": "Google Trust Services",
    "subject": "apyhub.com",
    "validFrom": "2026-10-28T13:26:45.000Z",
    "validTo": "2027-01-26T14:26:30.000Z",
    "daysRemaining": 70,
    "altNames": ["apyhub.com", "*.apyhub.com"],
    "protocol": "TLSv1.3"
  }
}
```

What each field tells you:

* **`issuer`:** the certificate authority that vouched for the site.
* **`validFrom` and `validTo`:** this certificate lasts about 90 days. Short certificates are becoming the rule (see below).
* **`altNames`:** the names it covers. `*.apyhub.com` is a wildcard for every subdomain.
* **`protocol`:** TLS 1.3, the current version.

## Do websites still use HTTP?

Very few. HTTPS made up about 30 to 45% of Chrome page loads in 2015 and roughly 95 to 99% by 2020, according to Google, after which progress mostly leveled off ([Google](https://blog.google/security/https-by-defau/)). Most sites that still load over HTTP are old pages, local network devices like routers, and internal tools.

Most sites that accept HTTP redirect it straight away. Requesting [`http://github.com`](http://github.com) returns a redirect to HTTPS:

```js
HTTP/1.1 301 Moved Permanently
location: https://github.com/
```

## What Chrome does with HTTP sites now

In October 2026, Chrome 154 turned on "Always Use Secure Connections" by default for public sites. Chrome now tries HTTPS first, and if a public site only works over HTTP, it shows a warning before loading it. You can click through, and Chrome stops warning about sites you visit regularly ([Google, October 28, 2025](https://blog.google/security/https-by-defau/)).

If your site still answers on HTTP, users now see that warning. Redirect HTTP to HTTPS, then turn on HSTS (HTTP Strict Transport Security). It's a response header that tells browsers to use HTTPS for your domain from then on, even if someone types or clicks an `http://` link:

```ts
Strict-Transport-Security: max-age=31536000; includeSubDomains
```

`max-age=31536000` means one year. Start with a shorter value while you test, because browsers remember the rule for the full period.

## Certificates are getting shorter

The CA/Browser Forum, which sets the rules for public certificates, approved ballot SC-081 on April 11, 2025 ([CA/Browser Forum](https://cabforum.org/2025/04/11/ballot-sc081v3-introduce-schedule-of-reducing-validity-and-data-reuse-periods/)). It cuts the maximum certificate lifetime in steps, now written into the forum's Baseline Requirements ([CA/Browser Forum Baseline Requirements](https://github.com/cabforum/servercert/blob/main/docs/BR.md)):

| From                  | Maximum lifetime |
| --------------------- | ---------------- |
| Before March 15, 2026 | 398 days         |
| March 15, 2026        | 200 days         |
| March 15, 2027        | 100 days         |
| March 15, 2029        | 47 days          |

Renewing by hand once a year won't work for much longer. Automate renewal, and monitor expiry dates so a missed renewal doesn't take your site or API down.

## HTTPS for APIs

For APIs, HTTPS isn't optional. API keys, bearer tokens and request bodies travel in every call, so one call over HTTP can leak a key. A few rules:

* **Only serve your API over HTTPS.** Reject HTTP requests rather than redirecting them. A redirect still means the first request, with its key, went out unencrypted.
* **Never turn off certificate checks in production.** Flags like `curl -k` or `verify=False` in Python make HTTPS no safer than HTTP.
* **Watch your certificate expiry.** An expired certificate breaks every client at once. The [SSL Certificate Details API](https://apyhub.com/tlderscom/service/domain-pricing-tld-registrar-information) returns `daysRemaining`, so a daily check can alert you weeks ahead.

ApyHub's endpoints are served over HTTPS, and the same certificate check is available through [ApyHub MCP](https://apyhub.com/mcp). Claude, ChatGPT, Cursor and other AI assistants can call it directly: ask "when does the certificate for my domain expire?" and the assistant uses a tested endpoint instead of writing its own check, which gives consistent results and uses fewer tokens.

[**Check a certificate with the SSL Certificate Details API →**](https://apyhub.com/tlderscom/service/domain-pricing-tld-registrar-information)

## Conclusion

HTTP and HTTPS speak the same protocol. HTTPS adds TLS, which encrypts the traffic, verifies the server and stops tampering, so passwords, cookies and API keys stay private. Almost the whole web uses it, Chrome now warns before loading HTTP sites, and certificate lifetimes are dropping toward 47 days. Use HTTPS everywhere, automate renewals, and check your expiry dates.

[**Start free on ApyHub, no card required →**](https://apyhub.com/)

## FAQ

### What is the main difference between HTTP and HTTPS?

HTTPS encrypts the connection with TLS and verifies the server with a certificate. HTTP sends everything as plain text that anyone on the network can read or change.

### Why is HTTP not safe?

Anyone between you and the server can read what you send, including passwords, cookies and API keys, and can change what you receive.

### Is HTTPS slower than HTTP?

The difference is small. The TLS handshake adds a little time to the first connection, and TLS 1.3 keeps it short. Browsers also only use the newer HTTP/2 and HTTP/3 over HTTPS, so a site that switches to HTTPS gets access to them.

### Is Google HTTPS or HTTP?

HTTPS. Google serves its sites over HTTPS and redirects HTTP requests to HTTPS.

### Do websites still use HTTP?

Very few public sites do. Roughly 95 to 99% of Chrome page loads use HTTPS. HTTP survives mostly on old pages, home routers and internal tools.

### What port does HTTPS use?

Port 443 by default. HTTP uses port 80.

### Is SSL the same as TLS?

TLS replaced SSL, and SSL is no longer used. People still say "SSL certificate", but today's certificates are used with TLS.

### What is the difference between HTTP and HTTPS proxies?

An HTTP proxy can read and change plain HTTP traffic and tunnels HTTPS traffic without reading it. An HTTPS proxy also encrypts the connection between you and the proxy.

### Does the padlock mean a site is safe?

It means the connection is encrypted and the site owns the domain. It doesn't mean the site itself is trustworthy, since phishing sites can have certificates too.

### How can I test an HTTPS API?

Send a request in [Voiden](https://voiden.md) or Postman, or with curl, and check the certificate and response. To check a certificate's issuer and expiry, call the [SSL Certificate Details API](https://apyhub.com/tlderscom/service/domain-pricing-tld-registrar-information), or ask an AI assistant connected to [ApyHub MCP](https://apyhub.com/mcp) to run it.

## About ApyHub

[ApyHub](https://apyhub.com/) runs a catalog of ready-made APIs and is the trusted operational layer between your application and the services it depends on, so your team builds and maintains less of its own code and ships faster. One subscription, billed in atoms, covers the whole [catalog](https://apyhub.com/catalog) of over 1,500 endpoints and capabilities, and it keeps growing. Every service is verified before it is listed and carries machine-readable certification covering GDPR, SOC 2 and ISO 27001. Every endpoint is MCP-ready by default. ApyHub runs dedicated EU and US regions and serves more than 65,000 developer workspaces every month. Start on the free tier with no card, or [publish your own API on ApyHub](https://apyhub.com/api-provider).

## Sources

* Google, [HTTPS by default](https://blog.google/security/https-by-defau/) (October 28, 2025): Chrome 154 default, HTTPS share of page loads
* CA/Browser Forum, [Ballot SC-081v3](https://cabforum.org/2025/04/11/ballot-sc081v3-introduce-schedule-of-reducing-validity-and-data-reuse-periods/) (April 11, 2025) and [Baseline Requirements](https://github.com/cabforum/servercert/blob/main/docs/BR.md): certificate validity schedule
* ApyHub, [SSL Certificate Details API](https://apyhub.com/tlderscom/service/domain-pricing-tld-registrar-information): apyhub.com checked November 17, 2026
