# How to find where players quit a Roblox experience

> Find where players quit a Roblox experience: an onboarding funnel and recurring funnels with AnalyticsService, what the Creator Hub's funnel page shows and what it doesn't, then the lag, server heartbeat and errors in the sessions that stopped at each step, so you and your coding agent can tell why players left there. With Luau you can copy.

Website: https://www.glitchless.gg/roblox-player-funnel.html · Roblox experiences, with Luau for server Scripts

New players decide quickly whether a Roblox experience is worth staying in, and the Creator Hub's retention numbers tell you how many came back, not where the rest stopped. To find where, mark the steps of a first session (spawned, finished the tutorial, started the first round, won it) and count how many players reach each one. `AnalyticsService` does that on Roblox's side, and the Creator Hub draws the funnel.

A funnel shows the step where players stop. It doesn't say why. So the second half of this guide puts what happened in those sessions next to the step: did the game lag there, did the server's heartbeat drop, did a script error? That's the part a coding agent can act on.

## The short answer

- **Onboarding funnel**: call `AnalyticsService:LogOnboardingFunnelStepEvent(player, step, stepName)` from a server Script as a new player reaches each step of their first session. It counts once per player.
- **Recurring funnels**: for flows players go through many times (the shop, a stage, a race), `LogFunnelStepEvent` with a funnel name and an ID for each attempt. An experience can chart up to ten funnels.
- **Stages**: Roblox's progression events don't show in any Roblox chart yet, so to see which stage loses players on the Creator Hub, give the stage a funnel of its own.
- **Read it**: the Funnel page of the experience's analytics on the Creator Hub, about a day later. Events only count from published games, never from Studio.
- **Why they left**: the step tells you where. Look at the same sessions' frame rate, server heartbeat and errors to find what went wrong there, then change one thing and compare the next version.

## Write down the steps of a first session

Before any code, list what a player should do in their first five minutes, in order, as things that happen in the game rather than screens. For a racing game that might be:

1. Joined
2. Picked a car
3. Started the first race
4. Finished the first race
5. Started a second race

Keep it to five to eight steps, each one something every new player should reach. The biggest drop between two steps is where to look first.

## Log the onboarding funnel

Call `LogOnboardingFunnelStepEvent` from a server Script when a player reaches each step, with the step's number (from 1) and a name. It's a one-time funnel: each player counts once, a repeated step only counts the first time, and logging step 3 counts steps 1 and 2 as done. To start the funnel as soon as a player joins, log step 1 on `PlayerAdded`.

ServerScriptService/Onboarding.server.luau:

```lua
local AnalyticsService = game:GetService("AnalyticsService")
local Players = game:GetService("Players")

local STEPS = { "Joined", "Picked a car", "Started first race", "Finished first race", "Started second race" }

local function reached(player, step)
	AnalyticsService:LogOnboardingFunnelStepEvent(player, step, STEPS[step])
end

Players.PlayerAdded:Connect(function(player)
	reached(player, 1)
end)

-- Then, wherever your game decides it:
-- reached(player, 2) when they pick a car, reached(player, 3) when their first race starts, and so on.
```

Call it from the server, where your game already decides what happened. Roblox only takes these events from servers, and only in published games: a play test in Studio sends nothing, so publish to a test place to try it.

## Recurring funnels: the shop, a round

Some flows happen many times a session: opening the shop, choosing an item, buying it. `LogFunnelStepEvent` takes a funnel name and an ID for each attempt, so two trips through the shop count separately. Roblox suggests a GUID as that ID, and keeps the 10 most recent IDs per player for each funnel.

A shop funnel:

```lua
local AnalyticsService = game:GetService("AnalyticsService")
local HttpService = game:GetService("HttpService")

local visits = {} -- player -> this shop visit's ID

local function shopOpened(player)
	visits[player] = HttpService:GenerateGUID(false)
	AnalyticsService:LogFunnelStepEvent(player, "Shop", visits[player], 1, "Opened shop")
end

local function itemViewed(player)
	AnalyticsService:LogFunnelStepEvent(player, "Shop", visits[player], 2, "Viewed item")
end

local function itemBought(player)
	AnalyticsService:LogFunnelStepEvent(player, "Shop", visits[player], 3, "Bought item")
end
```

## Which stage loses players

`AnalyticsService` has progression events for this (`LogProgressionStartEvent`, `LogProgressionCompleteEvent`, `LogProgressionFailEvent`), but Roblox's reference says they don't show in any Roblox-provided chart yet. Until they do, give the stage you're worried about a funnel of its own: started, reached the halfway point, finished, with an ID for each attempt. The funnel page then shows how many attempts got how far.

A stage as a funnel:

```lua
local AnalyticsService = game:GetService("AnalyticsService")
local HttpService = game:GetService("HttpService")

local attempts = {} -- player -> this attempt's ID

local function stageStarted(player)
	attempts[player] = HttpService:GenerateGUID(false)
	AnalyticsService:LogFunnelStepEvent(player, "Desert loop", attempts[player], 1, "Started")
end

local function reachedHalfway(player)
	AnalyticsService:LogFunnelStepEvent(player, "Desert loop", attempts[player], 2, "Halfway")
end

local function stageFinished(player)
	AnalyticsService:LogFunnelStepEvent(player, "Desert loop", attempts[player], 3, "Finished")
end
```

With ten funnels per experience, save them for the stages that matter: the first one, and any that players complain about. A player who leaves in the middle of a stage simply stops at their last step, which is often the most telling number.

## Read it on the Creator Hub

The funnels are on the Funnel page of the experience's analytics on the Creator Hub. Events are added up daily, so charts can take up to 24 hours to show; the View Events tool lists the most recent events in near real time, to check they arrive. Filters such as device apply to the first step, so a funnel is counted on the device a player started it on.

Read it as players: of 1,000 new players, how many reached each step? The step with the biggest fall is where to look first, and comparing it before and after an update tells you whether a change helped.

## Why players left at that step

Say the funnel shows 40% of new players never finish the first race. It can't say whether the race was too hard, the track loaded slowly on phones, the server lagged when it filled, or a script errored at the starting line. For that you need what happened in the sessions that stopped there, next to the ones that carried on:

- **Frame rate on their devices** during that step, by device kind. A phone at 20 fps on the starting grid is a reason to leave.
- **The server's heartbeat** while the step ran, by how many players were in it.
- **Errors** that happened at that step, and whether the sessions that hit one left soon after.
- **How long they waited** to load before the first step, and whether the slow joiners left first.
- **Deaths and fails** at that step: where players die over and over is where they give up.

Then change one thing, publish, and compare the new version's funnel and its lag and errors with the old one's. If the drop didn't move, the change wasn't the cause.

## The funnel and the reason, in one place

The [Glitchless module for Roblox](https://www.glitchless.gg/roblox.md) keeps the funnel and the evidence together. Your game marks levels (a race, a round, a stage) as they start, finish, fail or get left halfway, and every session also carries its frame times, stutters with their causes, its server's heartbeat, errors and loading time. So the step where players quit comes with what went wrong there, in players: how many reached it, how many left, and how many of those had lagged or hit an error first.

Your coding agent reads it over MCP. `glitchless_player_funnel` lists levels with starts, completions, fails and quits, and with hotspots shows where players die on one. `glitchless_triage` ranks problems by how many players they hit, and `glitchless_compare_versions` checks the next version with real players.

Ask your coding agent:

```text
Use Glitchless to find where new players quit my Roblox experience. Read the level funnel with glitchless_player_funnel and find the level that loses the most players. For that level, check whether those sessions lagged (glitchless_performance by device, glitchless_servers for the server's heartbeat) or hit errors (glitchless_triage) before they left. Tell me the likeliest reason, fix it, and after I publish, compare the new version with glitchless_compare_versions.
```

## Frequently asked questions

### Can I send AnalyticsService events from a LocalScript or from Studio?

No. Roblox only takes them from servers, in published games. Call them from a server Script where your game decides a step happened, and publish to a test place to check they arrive.

### What's the difference between an onboarding funnel and a recurring funnel?

An onboarding funnel follows a player's first session and counts each player once. A recurring funnel, `LogFunnelStepEvent`, is for flows a player can go through many times, like the shop, so each attempt gets its own ID.

### Do progression events show on the Creator Hub?

Not yet: Roblox's reference says progression events don't display in any Roblox-provided chart. Use a recurring funnel for the stages you need to see.

### Can I see why players left at a step?

Not from the funnel alone. Put the same sessions' frame rate, server heartbeat, errors and loading time next to it: if the players who left had lagged or hit an error first, that's your lead.

## Sources

- [Roblox: AnalyticsService (engine reference)](https://create.roblox.com/docs/reference/engine/classes/AnalyticsService)
- [Roblox: Funnel events](https://create.roblox.com/docs/production/analytics/funnel-events)
- [Roblox: Event types and limits](https://create.roblox.com/docs/production/analytics/event-types)
- [Roblox: Custom events](https://create.roblox.com/docs/production/analytics/custom-events)