← Back to journal
Backend / 2026.11.20

How websites know you’re not human

You’ve probably encountered a website asking you to prove you’re human. But how does it decide you’re suspicious in the first place? The answer involves much more than CAPTCHAs.

An animated illustration of browser and automated traffic passing through a security gateway that evaluates browser signals, request patterns and IP reputation.

You’re browsing a website, clicking through pages as usual, when suddenly you’re asked to verify that you’re human.

It’s a slightly strange experience. You’re clearly human, but somewhere behind the scenes, a system has decided that your request deserves closer inspection.

What exactly made it suspicious?

As a web developer, I find this problem particularly interesting because there isn’t a single reliable way to distinguish a human from an automated program.

Instead, websites collect several signals and make decisions based on how those signals fit together.

Your browser reveals more than you might expect

Every time you visit a website, your browser sends information to a server. Some of it is necessary for the website to function correctly.

Your IP address, HTTP headers, browser type and preferred language are just a few examples.

With JavaScript, websites can also observe certain browser characteristics, including screen resolution, time zone, supported features and graphics capabilities.

Individually, these details aren’t particularly unusual. Combined, however, they can form something known as a browser fingerprint.

A fingerprint isn’t necessarily unique or permanent, but it can help a security system recognize browser characteristics and detect inconsistencies.

Humans are surprisingly inconsistent

Think about how you normally browse a website.

You might read a paragraph, stop for a moment, scroll down, open another tab or move your mouse without clicking anything.

Your actions don’t follow a perfectly predictable schedule.

Automated programs, on the other hand, sometimes send requests at regular intervals or navigate through hundreds of pages without the pauses associated with normal browsing.

Some bot detection systems analyze patterns such as:

  • The frequency of incoming requests.
  • The timing between user interactions.
  • Mouse, touch and scrolling activity.
  • Navigation patterns across multiple pages.
  • Repeated requests to particular endpoints.

None of these signals is definitive. A human can behave predictably, and sophisticated automation can imitate some aspects of human behavior.

That’s what makes detection difficult.

The server sees another side of the story

Browser behavior is only part of the picture.

From the backend, engineers can observe information that isn’t necessarily visible to the user, including request frequency, session history, IP reputation and unusual access patterns.

Consider an e-commerce website where a normal visitor might open ten product pages within a few minutes.

Now imagine a client requesting thousands of product pages within the same period.

Even if every individual request looks valid, the overall pattern may suggest automated data collection.

A backend system can respond by applying rate limits, temporarily restricting requests or requiring additional verification.

HTTP 429, for example, indicates that a client has sent too many requests within a particular period.

The interesting part is that the request itself doesn’t have to be malicious. Sometimes the volume and timing are enough to justify additional scrutiny.

Why CAPTCHAs still exist

Modern bot detection often happens without the visitor noticing anything.

Services such as Cloudflare Turnstile and Google reCAPTCHA can evaluate various signals before deciding whether additional verification is necessary.

When the system isn’t sufficiently confident, it may present a challenge.

This is why two people visiting the same website can have completely different experiences. One person enters immediately, while another encounters a verification screen.

The system isn’t necessarily trying to establish your identity. It’s trying to estimate the risk associated with your request.

Not all bots are bad

This is where bot detection becomes more complicated.

Search engine crawlers, website monitoring tools, accessibility software and automated testing frameworks can all generate automated traffic for legitimate purposes.

Blocking every automated request would create unnecessary problems.

A well-designed security system needs to distinguish between helpful automation, suspicious activity and genuinely harmful traffic.

It also needs to avoid blocking legitimate users simply because they use a VPN, have unusual browser settings or interact with a website differently.

Security decisions come with trade-offs.

Looking at it from a backend engineer’s perspective

If I were designing bot protection for a web application, I wouldn’t rely on a single detection mechanism.

I’d start with basic rate limiting, request logging and session management. From there, I’d consider additional browser signals and risk assessment for sensitive operations such as account creation, authentication and payments.

Most importantly, I’d monitor false positives.

A security system that prevents legitimate customers from using an application creates a different kind of problem.

The goal isn’t to block every unusual request. It’s to protect the application without making it unnecessarily difficult to use.

The next time a website asks if you’re human

That small verification screen represents a much larger engineering problem.

Behind it are networking, browser technology, behavioral analysis, backend infrastructure and decisions about acceptable risk.

And despite all that technology, websites still can’t determine with absolute certainty whether every visitor is human.

They can only make an increasingly informed estimate.

That’s probably the most interesting part of the whole system.

Get in touch