← back to blog

Login Velocity: When Sign-Ins Across Accounts Look Coordinated

Picture twenty accounts that have never shared a device, a proxy or a password. Different fingerprints, different addresses, different names. Then the power goes out at the building where the machines running them sit. Forty minutes later it comes back, the machines boot, the browser profiles and phone apps reopen automatically, and all twenty accounts sign in within the same ninety seconds. To a platform watching logins, that minute looks nothing like twenty strangers. It looks like one operator restarting one setup. Fraud teams call this kind of signal velocity: how many of something happens within a window of time. Most people running accounts think about velocity inside one account, like how many actions per hour. This piece is about velocity across the fleet, where the question is whether separate accounts keep doing the same thing at the same moment, and what to do about it before and after the next outage.

What velocity means in fraud detection

Velocity is one of the oldest ideas in fraud prevention. Count how many times something happens for a given entity within a given window, and compare the count with what’s normal.

Card fraud systems have done this for decades. Five transactions on one card in a minute is unusual. Fifty transactions from one device across different cards in an hour is more unusual. The entity can be a card, a device, an IP address, an email domain, a shipping address or anything else that can be counted.

Login systems use the same idea. How many logins from this IP in the last ten minutes? How many failed logins for this account in the last hour? How many new accounts from this device today? Each of those is a velocity check, and each has a threshold that decides when extra scrutiny kicks in.

Most operators understand velocity inside one account. They know that a brand new account shouldn’t send a hundred messages in its first hour. What’s less obvious is that velocity checks can be run across entities that are supposed to be unrelated.

A platform can ask how many logins happened in this minute from this ISP’s range, or from this city, or from devices with this fingerprint family, or from accounts created in the same week. It can ask which accounts logged in within a few seconds of each other, and whether the same group keeps doing it.

That second kind of question is the one that catches fleets. It doesn’t need any shared identifier between the accounts. It only needs timing.

Timing works as a link because independent people behave independently.

Real users log in when they wake up, when they’re bored on a train, after lunch, before bed. Each person’s schedule is driven by their own life. Across a large population, logins follow broad daily curves, busier in the evening and quieter at night, but within those curves individual logins are scattered. Two strangers logging in within the same few seconds happens constantly by chance on a big platform, because there are so many people. The same two strangers doing it again and again, every day, doesn’t.

A fleet doesn’t behave independently, however well its accounts are separated. Its accounts share an operator, a schedule, a set of machines, a set of scripts and often a power supply and an internet connection. When those shared things change state, every account attached to them moves together.

So the signal is repeated coincidence. One overlap means nothing. Accounts that log in near each other once are unremarkable. Accounts that log in near each other on most days, or that all appear within the same minute after every outage, are displaying a pattern that independent people don’t produce.

This is the same logic the account graph uses for shared devices and addresses, applied to time. A shared IP is an edge between two accounts. So is a habit of appearing in the same short window. The difference is that timing edges are built slowly, from many small observations, and they’re easy to create without noticing.

How co-occurrence gets measured

Nobody outside a platform knows exactly how it measures timing links, but the general approach is standard enough to describe, and it helps to picture it.

Start with a log of login and session events, each with an account, a time and some context like the IP range, the city and the device family. Divide time into small windows, say a minute or a few minutes. For each window, list the accounts that had an event in it.

Now count pairs. For every pair of accounts, count how many windows they both appear in over a period. Most pairs of unrelated accounts share a few windows by chance, and the platform can estimate how many to expect from how active each account is and when. A pair that shares far more windows than chance would predict stands out.

Pairs combine into groups. If accounts A and B co-occur too often, and B and C do too, and A and C do too, those three form a cluster. Clusters can be scored like any other signal and fed into the account graph.

Context sharpens it. Co-occurrence within the same city or the same ISP range is more meaningful than co-occurrence across continents, because it rules out coincidences driven by global events. Co-occurrence of fresh logins is more meaningful than co-occurrence of ordinary activity, because fresh logins are rarer.

None of this needs a shared identifier. It works on accounts with different devices, different addresses and different names. That’s what makes timing links different from the others. Separating devices and addresses alone won’t fix them. The timing itself has to be separated too.

The restart burst

The single most common way fleets create a timing link is the restart burst.

Something stops. A power cut, an internet outage, a machine update that forces a reboot, a crash in the antidetect tool, a proxy provider going down for twenty minutes. When it comes back, everything that was running comes back at once.

Browser profiles set to reopen on launch reopen together. Phone apps set to start on boot start together. Automation schedulers that missed their runs catch up together. Every account that was signed in either resumes its session or tries to sign in again, within the same short window.

From the platform’s side, a set of accounts that were quiet for forty minutes all reappear inside ninety seconds. If they were on the same proxy provider during the outage, they also all went quiet at the same moment, which is a second matching edge.

A burst like this can matter even if nothing happens right away, because the platform can store the observation. If the same group bursts together after the next outage too, and the one after that, the link gets stronger each time.

The restart burst is especially easy to create with phones. A rack of cloud phones on one power supply reboots together. Each phone starts its apps together. Each app checks its session together. That’s the same moment repeated across every device on that circuit.

And it’s one of the few timing links you can see coming. Outages happen to everyone. The difference is whether your fleet comes back all at once or a little at a time.

Session resume versus a fresh login

Not every return after an outage is a login in the platform’s eyes, and understanding the difference helps you decide what to worry about.

When a browser profile reopens with a valid session cookie, the next page load usually just continues the existing session. The platform sees a request from an already authenticated session, perhaps from a new IP if the proxy changed. That’s a much quieter event than a login. Real people’s laptops wake up and resume sessions all the time.

A fresh login is different. The account submits credentials, or a login token, and the platform creates a new session. That’s recorded as a login event, often with the device, the IP, the time and whether any challenge was triggered. Login events are exactly what velocity checks count.

Several things turn a resume into a fresh login. Sessions expiring during the outage. A proxy change that the platform treats as suspicious enough to force re-authentication. Profiles that were set to clear storage on close. Apps that sign out when they lose connectivity for long enough. Automation that logs in at the start of every run instead of reusing the session.

So one practical rule follows directly. Keep sessions alive and let them resume rather than logging in again. An account that resumes a session after an outage produces a much weaker signal than one that submits a fresh login in the same minute as nineteen others.

It doesn’t remove the timing entirely. Resumed sessions still send requests at the same moment. But it’s the difference between a quiet overlap and a burst of the exact event that login velocity checks are built to count.

Scheduled jobs and round numbers

Outside of outages, the most common source of synchronised sign-ins is the schedule itself.

People who automate tend to schedule on round numbers. Every job at the top of the hour, or at nine in the morning, or every thirty minutes. Task schedulers and cron make that the easy default. If twenty accounts each have a job that starts at nine o’clock and logs in, twenty logins land at nine o’clock.

Even without automation, human operators create the same pattern. Someone who works through their accounts every morning opens them in the same order, at roughly the same pace, starting around the same time. The platform sees the same accounts appear in the same sequence, a minute or two apart, every day.

Token refresh intervals do it too. Some apps and tools refresh authentication on a fixed timer. If all the profiles were created or restarted at the same time, their timers stay aligned for as long as nothing disturbs them.

Proxy rotation on a timer adds another rhythm. If every account’s proxy rotates at the same interval, and the platform forces re-authentication on some rotations, the fleet logs in on that rhythm.

The fix for all of these is variation that looks like real life. Different start times, different orders, different gaps. Schedules that are genuinely different per account and that drift from day to day, the way a person’s does.

What real login patterns look like

It helps to know what you’re trying to resemble, because over-randomising can create its own pattern.

Real people log in on daily cycles tied to their time zone. There’s a morning bump, a quieter working day, an evening peak and very little between the early hours and dawn. Weekends shift the curve later. Holidays and events change it.

Individual people are irregular within that cycle. Someone might check an app at 7:40 one day and 8:15 the next. Some days they don’t open it at all. Some days they open it five times.

Most real accounts don’t log in freshly very often. They stay signed in on their phones for weeks or months, and the platform sees a stream of activity from an existing session rather than repeated logins. Fresh logins happen when someone gets a new phone, reinstalls an app, clears their browser or signs in on a second device.

So an account that submits a fresh login every day at the start of a scripted run is already unusual on its own, before any cross account comparison. An account that stays signed in and shows activity scattered across its persona’s waking hours looks ordinary.

For a fleet, the target is each account following its own plausible daily curve, in its own time zone, with its own irregularities, and rarely logging in from scratch. Accounts that look like real people individually tend not to line up with each other, because real people don’t.

The persona’s clock versus yours

Timing links get stronger when an account’s activity doesn’t fit the clock of the person it claims to be.

Every account has an implied time zone. It comes from the IP’s location, the device’s time zone setting, the language, the phone number and the content it posts. A real person in that time zone is active during their own day and asleep during their own night.

A fleet run by one operator tends to follow the operator’s clock instead. If you’re in Singapore running accounts that claim to be in several countries, all of them tend to be active during Singapore working hours, because that’s when you’re at the desk. For the Singapore accounts, that fits. For an account claiming to live in New York, it means activity in the middle of that person’s night, every night.

That’s a problem on its own, since a New York account that’s only ever active at 3am New York time is unusual. It also strengthens the cross account link. Accounts that claim different time zones but are all active in the same few hours of one real clock are showing the operator’s schedule through their personas.

The fix is uncomfortable but simple. Accounts should be active in their own daytime. If you can’t be at the desk during a persona’s day, either schedule that account’s activity for its own daytime or reconsider running accounts in time zones you can’t cover.

It also means that a recovery plan after an outage should respect each account’s clock. Bringing a New York account back online at what’s 4am for its person is a strange first act after being away.

Phones and background sync

Phones add a timing source that desktop profiles don’t have, which is the operating system’s own scheduling of background work.

Android and iOS both batch background tasks to save battery. Apps register work they’d like to do, like syncing messages or refreshing a feed, and the system runs it at moments it chooses, often grouping several apps’ tasks together. When a phone regains a network connection after being offline, pending work from many apps tends to run at once.

On one real phone, that’s invisible to anyone, since each app only sees its own sync. On a rack of phones that lost their connection together, every phone does the same thing when the connection returns. Every copy of the same app on every phone syncs within the same short window. For the app’s servers, that’s a cluster of its own accounts all reconnecting and syncing in the same minute, from the same city or the same carrier range.

Push notification connections behave similarly. Each phone keeps a connection open to the platform’s push service, and after an outage every phone re-establishes it at once.

You can’t turn background sync off without making the phones behave unlike real phones. What you can do is avoid the shared outage in the first place, with steady power and separate network paths where it matters, and bring phones back online in stages when an outage does happen. A phone that reconnects twenty minutes after its neighbour doesn’t sync in the same minute.

The failed login problem

There’s a special case of velocity that catches fleets in a particularly damaging way: failed logins.

Platforms watch failed login attempts closely, because they’re the signature of credential stuffing, where attackers try leaked usernames and passwords against a site at scale. A burst of failed logins across many accounts from related sources is exactly what stuffing looks like.

Fleets produce this pattern more often than you’d think. A password manager export with a formatting error that breaks every password. A change of passwords on the platform that the automation didn’t pick up. A tool update that stored credentials differently. An expired proxy authentication that makes every login attempt time out and retry.

In each case, many accounts fail to log in within a short window, often repeatedly as scripts retry. To a platform, that looks like an attack on those accounts. The response is usually protective, like forcing a password reset, locking the account or adding a challenge, which from the operator’s side looks like a wave of lockouts.

The fix is to fail loudly on your side instead of theirs. If the first two or three login attempts in a batch fail, stop the batch and find out why before trying the rest. Never let a script retry failed logins in a tight loop. Treat an unexpected login failure as a reason to pause, not to try again.

A wave of lockouts caused by your own broken credentials is one of the most avoidable problems in running a fleet.

Verification prompts arriving together

Timing links also show up on the other side of the login, in the challenges platforms send.

When a platform is unsure about a login, it may ask for a code by SMS or email, or a confirmation on another device. If many accounts in a fleet trigger challenges at the same time, the challenges themselves arrive together. The operator then clears them in a burst, often in the same order, often from the same place.

That’s two timing events stacked. The logins that triggered the challenges, and the responses to them. If the SMS numbers or email inboxes behind the challenges share infrastructure, the responses also share a source.

It’s worth noticing when challenges arrive together, because it’s often a sign that something shared has already been seen. A group of accounts that all get challenged within the same hour, when they usually don’t, has probably been scored together for some reason. It might be the restart burst, a proxy change, a tool update or something else.

When that happens, resist clearing all of them in one sitting. Spread the responses out, in different orders, over hours rather than minutes. Look for what the challenged accounts have in common before the next batch of logins, because whatever it is will likely cause the same thing again.

And keep a note of it. Challenges arriving in groups are one of the few pieces of direct feedback a platform gives you about how it sees your fleet.

Coming back from an outage

Outages are going to happen, so it’s worth having a plan for the return before you need one.

First, stop things from coming back automatically. Browser profiles that reopen on launch, apps that start on boot, schedulers that catch up on missed runs. Each of those turns a recovery into a burst. Decide in advance whether each account should resume automatically or wait for you.

Second, bring accounts back gradually. Start with a few, spread across different proxies and platforms, and add more over the next hours. The accounts that matter most don’t need to be first. They need to not be part of a crowd.

Third, prefer resuming sessions over new logins. Check whether an account’s session is still valid before doing anything that would log it in afresh.

Fourth, don’t replay the backlog. If an account missed three scheduled actions during the outage, it doesn’t need to do all three the moment it’s back. Real people who were offline for an hour don’t compensate by doing an hour’s worth of activity in two minutes.

Fifth, stagger by more than seconds. A burst spread over five minutes is still a burst. Think in hours.

For phone racks, the same applies at the hardware level. Staggered power, or phones that don’t auto start their apps, turns a single moment into a spread.

Staggering without creating a new pattern

The obvious fix for synchronised timing is to add random delays. It works, as long as the randomness is shaped like real behaviour.

A fixed random delay added to a fixed schedule doesn’t help much. If every account’s job runs at nine o’clock plus somewhere between zero and five minutes, the fleet still clusters in a five minute window every morning. The window is just wider.

Better is giving each account its own schedule, anchored in its own persona. An account whose person lives in Singapore and works office hours might be active around breakfast, at lunch and in the evening. Another account’s person might be a night owl. Each account’s schedule then varies day to day around its own anchors.

Order matters too. If you open accounts by hand, don’t always open them in the same order. The same sequence, every day, is a timing pattern even with varying gaps.

Skipping days matters. Real people don’t use every app every day. An account that’s active every single day at the same broad times is less ordinary than one with occasional quiet days.

Watch for accidental alignment. Accounts created on the same day often end up on the same rhythm, because their timers and schedules started together. Spreading creation dates helps later.

The goal is that if you plotted every account’s activity on a timeline, you’d see a set of independent people, not a single rhythm with twenty lines on it.

The infrastructure behind the timing

Some timing links come from infrastructure you’d never think of as a timing source, and they’re worth checking for.

Shared power is the first. A rack of phones or a room of machines on one circuit goes down and comes back together. A small UPS doesn’t fix the recovery burst, but it can turn short cuts into no event at all.

Shared internet is the second. If every proxy or every phone in a fleet ultimately depends on one uplink, an outage on that uplink takes every account offline at once and brings them back at once.

Shared proxy providers are the third. A provider outage drops every account using that provider in the same instant. When it recovers, every connection reconnects in the same minute. Spreading accounts across more than one provider means an outage affects part of the fleet rather than all of it.

Shared tools are the fourth. An antidetect tool update that forces a restart, or a crash in a shared automation server, restarts everything it runs.

Shared maintenance is the fifth. If you reboot every machine on the same night for updates, you’ve scheduled a restart burst.

None of these can be eliminated completely. Each one can be spread. The more independent failure domains a fleet has, the fewer accounts move together when one of them fails.

A worked example after a power cut

Here’s a hypothetical to put the pieces together.

An operator runs thirty accounts across two machines and a small rack of phones, all in one room. Browser profiles are set to reopen on launch. The phones auto start their apps. A scheduler runs posting jobs on the hour. All proxies come from one provider.

At 2:10 in the afternoon, the power fails for forty minutes. At 2:50 it returns. The machines boot, the profiles reopen, the phones restart. Within two minutes, all thirty accounts are back. Eight of them had sessions expire, so they submit fresh logins. The scheduler sees it missed the 3:00 run’s preparation and fires the backlog. Three accounts trigger verification prompts, which the operator clears one after another.

To a platform, that’s thirty accounts disappearing together, reappearing together, eight fresh logins in one minute, a burst of posting, and three challenges answered in sequence.

Now the same outage, handled differently. Profiles don’t reopen on launch. Phones boot but don’t start their apps. The scheduler skips missed runs. Over the next three hours, the operator brings accounts back in small, mixed groups, checking sessions first. The backlog is dropped. The three challenged accounts are answered at different times.

The outage still happened to everyone. The second version just didn’t announce it.

What to do this week

If you’ve never looked at your fleet’s timing, here’s a short list.

Turn off automatic reopening and auto start for accounts that don’t need it, so an outage doesn’t become a burst by default.

Look at your schedules. Replace round number start times with per account schedules that vary day to day.

Check whether your automation logs in fresh on every run. Change it to reuse sessions where possible.

Add a stop rule for failed logins. Two or three failures in a batch pauses the batch.

Write a short recovery plan for outages, including the order and the pace for bringing accounts back.

Spread accounts across more than one proxy provider and, if you can, more than one power and network path.

Start logging challenges by time, so you can see when several arrive together.

The honest limit

Timing is one signal among many. Staggering your fleet won’t protect accounts that are linked by devices, addresses or payment details, and a burst after one outage is unlikely to decide anything by itself.

I can describe how velocity checks work and why repeated co-occurrence links accounts, because that’s standard in fraud detection. I can’t tell you what windows or thresholds any platform uses, or how much weight it gives timing compared with everything else. Those are internal and they change.

What I can say is that timing is the link people create most easily and notice least. It doesn’t show up in a fingerprint checker or a proxy test. It only shows up when you look at your fleet the way a platform does, as a set of events on a clock.

I run Singapore mobile proxy and cloud phone farms myself, where outages and restarts are a normal part of running hardware, so how a fleet comes back matters as much as how it runs. If you want the rest of the operations picture, start on the Multi Account Ops home page.

Get new guides and videos first — join the Telegram channel.

need infra for this today?