Telegram logoTelegramXaro Download Hub

Telegram Features · October 23, 2026

How Does Telegram Live Location Sharing Work in Group Chats?

Telegram live location in group chats: exact sharing paths for Android, iOS, and Desktop, retention and deletion rules, and audit-friendly group workflows.

by Telegram Official Team#Live Location#Group Chats#Location Sharing#Privacy Settings
how to share live location in Telegram group, Telegram live location sharing, Telegram group chat location, stop live location Telegram, live location not updating Telegram, Telegram live location duration, Telegram location privacy settings, share live location step by step, Telegram group live location guide

How Does Telegram Live Location Sharing Work in Group Chats?

Using Telegram live location in group chats looks almost too simple: you open the attachment menu, choose Location, pick a duration, and a moving pin appears in the conversation. The interesting part begins after that. What does the pin leave behind when the countdown reaches zero? Who can still see it next week? Can an administrator reconstruct who shared what, and when? This guide looks at the feature through a compliance and data-retention lens — auditability first — while still giving you the exact taps for Android, iOS, and Desktop.

Two framing points before we start. First, most of what follows describes client behavior you can verify yourself in a few minutes; where a claim depends on your platform or the specific build you are running, it is marked as an empirical observation and paired with a reproducible test rather than stated as an absolute. Second, version drift is real — Telegram ships updates frequently, so menu labels and the placement of controls move around. Treat the paths below as the shortest current route in the latest version as of this writing, and use the search field inside Settings if a label has been renamed on your device.

What Telegram Live Location Is — and What It Is Not

Telegram live location is not a setting or a permission you switch on once. It is a message type. When you send one, you create a message that carries a coordinate pair which the client refreshes for a fixed period you select at send time. In the latest version as of this writing, that period comes from a small set of preset durations — commonly fifteen minutes, one hour, and eight hours. The message renders inside the group timeline as a map thumbnail; opening it expands the map and shows the sharer's current position, with a countdown indicating how much time remains. Everything that follows in this article — who can see it, how long it lingers, who can remove it — derives from that one design decision: a live location is a message, not a mode.

That definition immediately separates it from the static location pin most people have used at least once. A static pin is a snapshot: it captures where you were at the moment you pressed send and never changes. A live location is a stream with an expiry. Both are ordinary messages in the chat history, both are subject to the same forwarding, copying, and deletion rules as any other message, and both persist until someone removes them. The difference is that one of them keeps updating while the clock runs — and, as the next sections show, that difference has consequences long after the clock stops.

It is just as important to be clear about what the feature does not provide, because teams routinely arrive with expectations shaped by fleet-tracking software. There is no route history, no speed log, no trip replay, no geofence, and no automated alert when somebody stops moving. Each live location message shows exactly one marker for one sharer. If you have eight people in the field and all eight share, you get eight independent messages that happen to live in the same chat; you do not get a combined operations map. If your requirement is "show me where everyone was at 14:20 yesterday," live location cannot answer it, and pretending otherwise leads to compliance gaps later.

Availability also has boundaries tied to the chat type. Live location is a posting action, so it belongs to conversations where you are allowed to send messages — private chats and groups, including supergroups. In a broadcast channel, where ordinary subscribers cannot post, the sharing flow is not available to them at all. (This is a widely observed behavior; if your client shows something different, test it in a group of your own before relying on it.) Groups are also cloud chats: they are stored server-side and synchronised across your devices, which is precisely why the retention question matters so much in a group context and why a group is not the right container for a location you want to be genuinely ephemeral.

When is live location the wrong choice even inside a group? Three cases come up repeatedly. The first is duty-of-care tracking across many hours: an eight-hour ceiling means a multi-day convoy keeps having to re-share, and each re-share is a new message with a new retention tail. The second is anything requiring an escalation path — live location will not tell you that a person has been stationary for forty minutes. The third is any workflow where a participant has not clearly consented to continuous position sharing; a moving marker is a different category of data from a one-off pin, and the difference is easy to underestimate when the interface makes sharing a single tap. In all three cases the honest conclusion is the same: the feature is being asked to do a job it was not designed for.

What Telegram Live Location Is — and What It Is Not
What Telegram Live Location Is — and What It Is Not

The Compliance Lens: Three States Every Live Location Passes Through

If you remember nothing else from this article, remember that a live location exists in three distinct states, and each one carries different obligations. Active: the countdown is running, the marker updates, and every member who can read the chat can watch the position change in near real time. Expired: the countdown has ended, updates have stopped, but the message itself remains in the chat history. Deleted: the message has been removed, either by its author or by a moderator with deletion rights. Most retention policy mistakes come from collapsing the middle state into the first or the last.

The middle state is where most compliance surprises live. When the timer runs out, the message does not vanish. Based on repeated empirical observation in current clients, it settles into a static-looking map preview showing the last known position — the place the sharer was when the countdown stopped. That preview stays in the group until someone deletes it, which could be hours, months, or forever in a quiet archive group. In a private chat between two people this is a minor quirk. In a group of forty field contractors with a two-year history, it means the last known location of every person who ever shared is still sitting in the message archive.

Verify this yourself before you design a policy around it. Create a test group with one colleague. Share a live location for the shortest available duration. Wait for the countdown to finish. Then ask your colleague to scroll to the message and describe what they see, and to tap it. If the preview still displays a position after expiry, your retention policy must cover it. If your client behaves differently, note the build and platform, because that difference changes the policy.

Deletion is the second lever, and it is a shared one. The person who shared a live location can delete their own message, and in a group, an administrator holding the delete-messages permission can remove someone else's message as well. When a message is successfully deleted for everyone, it disappears from the clients of the participants. What deletion cannot do is reach backwards in time: a screenshot taken while the marker was active, a forwarded copy, or a note written by hand all survive independently of the chat. For auditability discussions, this is the honest framing — chat deletion manages the chat, not the world.

There is also a timing question attached to deletion that is worth testing rather than assuming. Telegram has, over the years, adjusted the window within which a message can be removed for all participants, and administrator deletion in groups may behave differently from an author deleting their own message. Before you write "delete within X hours" into a procedure document, run the test described later in this article and record what your current client actually permits.

Finally, storage location. Group chats on Telegram are cloud chats; the messages, including location messages, are held on Telegram's infrastructure rather than only on the participants' devices. You cannot select a data region, and you cannot run a group chat on a self-hosted store. Whatever your organisation's data-residency posture, the correct move is to read Telegram's published privacy policy for the authoritative description of what is stored and for how long, and to treat this article as an operational companion rather than a legal substitute. Policies are updated; secondary summaries age badly.

Quick Start: Sharing a Live Location in a Group (By Platform)

The shortest path is the same idea on every platform — attachment menu, then Location, then the live option — but the labels and the number of taps differ enough that a step-by-step is worth writing down. The paths below assume you are already a member of the group and are allowed to post in it.

Android

Open the group, tap the attachment (paperclip or plus) icon next to the message field, and choose Location. The map picker opens centred on your current position. Rather than sending the pin immediately, look for the live-location control in the same picker — it is presented as a sharing option with a duration choice, typically offering the preset durations noted earlier. Select the duration, confirm, and the message is posted to the group. If your organisation manages the device, remember that the operating system's location permission for Telegram must be granted; if it was denied earlier, the map will open but the marker will not resolve, which is a permission problem rather than a Telegram problem.

iOS

Open the group, tap the attachment icon, and choose Location. The same map picker appears with a live sharing option and the duration presets. On iOS, pay attention to the system-level location permission you granted: "While Using the App" and "Always" produce different reliability profiles when the phone is locked or the app is in the background. If you plan to share for an eight-hour shift, test the permission mode in advance, because a permission that works fine for a fifteen-minute walk may behave differently over a long day. This is an empirical observation about background behaviour rather than a fixed rule — confirm it with the test in the verification section.

Desktop and Web

On the desktop client, the same entry point exists: open the group, click the attachment (paperclip) icon, and select Location. A map window opens where you place or confirm a point before sending. Live sharing is exposed in that window as an option near the send control, with the duration presets. Desktop clients generally have no continuous location hardware, so the position is derived from what the operating system and network can provide; on a laptop in a moving vehicle, expect the marker to be noticeably coarser than from a phone. If your Desktop build exposes only a static pin and no live option in that context, check for updates before concluding the feature is missing — availability in the desktop map window has varied across builds.

Shortest reachable path, condensed: group → attachment icon → Location → live sharing option → choose 15 min / 1 hour / 8 hours → send. Alternative entry point on mobile: the map picker itself often surfaces a live-sharing button when you tap the current-position marker, which saves one step once you know it is there.

When the Live Option Is Not Offered

Occasionally the picker opens and you see only the static-pin controls. The usual explanations, in rough order of likelihood: you are trying to post somewhere you do not have posting rights; the operating system has withheld location permission; the app is several versions behind; or you are in a context where the client does not expose live sharing. The fallback is straightforward and still auditable — send a static pin, then replace it manually at agreed intervals, deleting the previous pin each time. It is more work and produces a noisier chat, but it gives you an explicit trail of check-ins rather than a single fading marker, which some compliance reviewers actually prefer.

Choosing a Duration: A Retention Decision Disguised as a UI Choice

Duration is the most consequential setting in the entire flow, and it is presented as a casual three-way choice. Think of it as choosing how long you consent to continuous position disclosure, not as choosing how long your errand takes. The three presets map onto three quite different categories of data, and the sections below take them in turn.

The fifteen-minute option is the right default for a single meeting point, an airport pickup, or a "find me near the north gate" moment. The exposure window is small, the last-known position is likely to be somewhere unremarkable, and if you forget about it the residual data is a pin outside a building. This is the only duration that should be used casually.

The one-hour option suits a delivery round, a technician's site visit, or an event staffer rotating through a venue. It is long enough to be useful without leaving a marker running through an entire workday. From a retention perspective, an hour of positional data still describes a path — where someone went, how long they stayed — which is a meaningfully richer dataset than a single point. Example: a technician who shares for one hour before a site visit leaves a trace from which an observer can infer the route taken and roughly how long they lingered at each stop, even though no route history is ever displayed.

The eight-hour option is effectively a shift-length disclosure. If you choose it, understand that you are publishing a continuous trace of an entire working day to everyone in that group, including anyone who joins the group in hour six and can scroll back through the message. It is justified for long field operations with an explicit consent process; it is overkill for almost everything else.

There is a practical asymmetry worth noting: sharing longer is far easier than sharing shorter. If a share expires early, you can send another one in seconds. If a share is still running, you can end it sooner than the preset — but the residual message, and the last position recorded at the moment you stopped, remains in the chat either way. Choose the shortest duration that covers the task and accept the mild inconvenience of re-sharing.

Group-Level Controls: Permissions, Pinning, and Admin Oversight

Groups give administrators fewer location-specific levers than people expect. Based on current clients, there is no dedicated toggle labelled "allow live location" in group permissions. What you have instead is a coarse instrument: send-messages and send-media style permissions, which restrict posting broadly rather than isolating location. Empirically, toggling a media restriction may or may not suppress the location option depending on how the client classifies that message type; do not assume it works — test it in a sandbox group and observe whether the attachment option still produces a live location.

Where administrators do have real influence is discoverability and cleanup. Pinning the active live location message keeps it at the top of the chat instead of letting it scroll away under two hundred messages of chatter, which matters enormously in busy groups where the marker would otherwise be functionally invisible. Pinning requires the pin-messages permission, so in a large group you will typically designate a coordinator rather than expecting everyone to manage it. Equally, whoever holds delete rights becomes the de facto retention officer: they can remove an expired location message long before anyone remembers it exists. Between those two levers — pinning while active, deleting once expired — an administrator can shape the group's exposure without touching a single permission setting.

Telegram groups also expose an administrative action log, usually surfaced as Recent Actions in the group's management or settings area. In practice this log records administrative events, including deletions performed through administrator actions, which makes it the closest thing to an audit trail the platform offers for group moderation. Whether a member deleting their own location message produces an entry is a different question — observation suggests self-deletions are not reliably captured, since they are not administrative events. If the distinction matters to your audit design, run the controlled test in the verification section and record the result rather than relying on either assumption.

A Naming Convention That Costs Nothing

Because the map preview carries no room for explanation, groups that take auditability seriously tend to enforce a one-line companion message. Example: "LIVE — Ana, north route, ends 14:30" posted immediately before the share gives reviewers context that the map itself cannot. This is not a Telegram feature; it is a human convention, and it is the cheapest improvement available. It also helps during incident review, when the question is rarely "what coordinates" and almost always "what were they doing and until when."

Intermediate: A Field Workflow You Can Adapt

Consider a hypothetical but realistic setup: a twelve-person field survey team working a site across three staggered shifts, coordinated through a single Telegram group that also contains two remote coordinators. The naive approach — everyone shares for eight hours at the start of the day — produces twelve simultaneous markers that nobody can visually separate, a chat full of overlapping map previews, and an archive in which every person's last known position is stored indefinitely.

A more defensible structure would look like this. Each shift shares only for the span of its own activity, using the one-hour preset and re-sharing when it lapses, so the active marker always corresponds to someone who is actually working. Shares are announced with a companion text line so the chat reads as a log. The coordinator with pin rights pins the currently active shares and unpins them when they expire. At the end of the shift, the coordinator — not the sharer — sweeps the expired messages and deletes them, using a single consistent person so the deletion is recorded in the administrative log and attributable.

The reason this pattern works is that it separates three functions that the default interface merges: consent (the shortest viable duration), visibility (pinning), and retention (deletion by a named role). The reason not to adopt it is scale — in a group of three people, a coordinator role and a sweep routine is bureaucracy for its own sake. Reserve the ceremony for groups where positions are sensitive, membership changes frequently, or an external party may later ask what happened.

One more intermediate tool deserves mention: the auto-delete timer available for chats. Setting a timer causes messages to be removed automatically after a chosen interval, which is a strong retention control when it applies to your situation. Use it with your eyes open, though. An auto-delete timer that fires before a review is needed destroys the very record you might rely on, and because it operates uniformly it will also remove ordinary text messages that carried the context. Where the option is available in your client, decide first whether the group is a working channel or a record, because auto-delete assumes it is the former.

Three End States: Expiry, Early Stop, and Deletion

These are constantly conflated, and the confusion produces bad policies. Expiry is passive: the countdown ends, updates cease, and the message remains with its last recorded position. Nothing else changes. Early stop is an explicit action by the sharer during an active session; it ends the updating immediately, but it does not remove the message, so a final position is still written into the chat. Deletion is the only state that removes the artefact, and it requires either the author or an administrator to act.

Practically, this means "the location stopped" and "the record is gone" are different statements, and reports that treat them as synonyms will be wrong. In current clients the controls for stopping an active share appear on the message itself or in the expanded map view; the exact placement varies between platforms and builds, so the reliable instruction for a field team is simply that the share can be ended from the shared message, and that ending it is not the same as erasing it. If a policy says a location must not persist, the deletion step is mandatory and must be assigned to someone.

A frequently asked variant: what happens if the sharer simply stops using Telegram, or the phone dies? Updates stop, the countdown may continue to elapse, and what remains is the last position that was successfully recorded before the interruption. Viewers often describe the marker as "stuck." That is the observable behaviour, and it is another argument for short durations — a stuck marker with a long countdown invites the group to draw conclusions from stale data. It also illustrates why an early stop is worth performing deliberately: a share that is ended cleanly leaves a position the sharer chose, whereas one that dies with the battery leaves whatever was last transmitted.

Advanced: Bots, the Bot API, and Location Feeds You Control

If you need location sharing that behaves predictably and leaves a trail you own, the Bot API is the documented path. Telegram's Bot API exposes methods for sending a location with a live period, for editing an existing live location, and for stopping it. Concretely, a bot can post a live location into a group and then move it, which is exactly what you want for a single shared asset rather than a person — a convoy marker, a shuttle bus, a mobile equipment unit. Check the current Bot API reference for the exact bounds of the live period parameter and for the current method names; the shape of the call is stable but details do change.

POST https://api.telegram.org/bot<token>/sendLocation
{
  "chat_id": "<group_chat_id>",
  "latitude": 00.000000,
  "longitude": 00.000000,
  "live_period": 3600
}

POST https://api.telegram.org/bot<token>/editMessageLiveLocation
{ "chat_id": "...", "message_id": 0, "latitude": 0.0, "longitude": 0.0 }

POST https://api.telegram.org/bot<token>/stopMessageLiveLocation
{ "chat_id": "...", "message_id": 0 }

The compliance advantage here is control of the record. A bot posting a live location creates a message with a known author, a known start, and a known end; if you also record the coordinates your bot pushes, you end up with your own dataset instead of a chat artefact. The obligation that comes with it is the mirror image: the moment you log coordinates outside Telegram, you own their retention, access control, and deletion schedule. Teams frequently adopt a bot for auditability and then forget that the log they built is now the most sensitive store they operate.

Apply least privilege when you wire a bot into a group. A location-relaying bot needs to send messages and manage its own messages; it does not need to read the broader conversation, it does not need to be able to delete other people's messages, and it should not be an administrator unless there is a specific, articulated reason. Where a bot is used to relay positions, prefer a dedicated bot with a token scoped to that one group over a general-purpose automation bot shared across the organisation. If a token leaks, the blast radius is one chat.

Careful with third-party location bots. Any bot that receives location data receives it on someone else's infrastructure. There are many utilities in this space and they change frequently, so this article deliberately does not recommend specific ones. Before adopting any of them, verify who operates it, where it stores data, whether it retains coordinates, and whether it can be removed from the group without leaving its records behind. A bot that "just shows a map" is still a data processor.

One boundary is worth stating plainly: whether a bot receives continuous updates from a user's live location, as opposed to moving its own, depends on the current update semantics of the Bot API and is best verified against the official documentation and your own update log rather than assumed. The reproducible check is simple — have a bot you control sit in a test group, have a human share a live location, and inspect what your bot actually receives over the following minutes.

Troubleshooting: Symptom, Likely Cause, Verification, Fix

Symptom Likely cause Verification Fix
Map opens but no position is resolved Operating-system location permission denied or set to a restrictive mode Check the app's permission entry in system settings Grant location access; on iOS, confirm whether while-in-use is sufficient for your duration
Marker freezes while the countdown still runs App backgrounded, device power saving, or loss of signal Ask a second member to compare the marker against the sharer's actual position Keep the app available, exclude it from aggressive battery optimisation where the platform allows, and prefer shorter shares
No live sharing option in the picker Posting rights, permission, client build, or chat type Try in a private chat of your own; if it appears there, the group is the variable Adjust group permissions or use the static-pin fallback
Expired location still visible to members Expected behaviour: the message persists with the last position Run the expiry test described below Delete the message; assign a named role to do it
Deletion not possible for everyone Author is not you, or a deletion window applies in your client Attempt deletion on a test message of known age Have an administrator with delete rights remove it, and record the action

A note on the third row: "the group is the variable" is the single most useful diagnostic in this table. Because live location is a posting action with permission dependencies, isolating the chat type by testing in a private chat separates a permissions problem from a client problem in about thirty seconds. The last two rows, by contrast, are not faults at all — they describe expected behaviour that simply has to be handled by process rather than by a setting.

Troubleshooting: Symptom, Likely Cause, Verification, Fix
Troubleshooting: Symptom, Likely Cause, Verification, Fix

Reproducible Verification: Four Tests You Can Run in Ten Minutes

Every claim in this article that is marked as observed behaviour can be checked with the following four tests. Run them once on each platform your team actually uses, record the results, and keep the notes — a one-page internal record beats any external guide, including this one.

  1. The expiry test. Create a two-person test group. Share a live location using the shortest available duration. Wait until the countdown ends without touching anything. Have the second person open the message and describe what is shown. Expected observable result: the message remains and displays a position rather than disappearing. Record the exact presentation your client gives.
  2. The deletion test. From an older test message, attempt deletion for everyone as the author. Then attempt the same from an administrator account on a message authored by someone else. Expected observable result: one or both succeed depending on rights and timing. Record which, and how old the message was.
  3. The background test. Share a live location for roughly one hour. Lock the phone, leave the app fully closed for several minutes, then check from a second device or ask a colleague whether the marker moved while the app was shut. Expected observable result: a qualitative difference in update frequency between app-open and app-closed states. This is exactly the kind of behaviour that varies by platform, so trust your own measurement, not a generalisation.
  4. The admin-log test. Open the group's Recent Actions view. Perform an administrative deletion of a location message, then separately have a member delete their own. Refresh the view and note which actions are recorded and which are not. Expected observable result: administrative events appear; self-deletions may not. This determines whether your audit trail can attribute cleanup to a person.

These tests are deliberately about qualitative behaviour — does the marker move, does the entry appear — because precise timing figures from someone else's phone tell you nothing about yours. Treat any externally published performance number, including this article's, as a prompt to measure rather than a fact to cite. Re-running the set after a major client release takes ten minutes and is the cheapest way to keep your internal record honest.

Reference Table: Platform Paths and Capability Overview

The table below condenses the operational picture. It describes behaviour observed in the latest version as of this writing and should be re-verified after major client updates, since menu structure is the part of Telegram that changes most often.

Aspect Android iOS Desktop
Entry point Attachment icon → Location Attachment icon → Location Paperclip → Location (map window)
Duration presets Short / medium / long options offered at send time Same presets offered at send time Presets exposed near the send control; verify in your build
System permission dependency Location permission required; battery optimisation may affect updates Location permission mode affects background reliability Relies on OS/network positioning; typically coarse
Post-expiry message Remains until deleted (observed) Remains until deleted (observed) Remains until deleted (observed)
Deletion for everyone Available to author and to authorised admins; window may apply Same Same
Admin action log Recent Actions in group management Recent Actions in group management Recent Actions in group management

Read the table as a starting checklist, not as a specification. The rows that matter most for compliance are the fourth and fifth: post-expiry persistence and deletion capability. Those two determine whether your group accumulates a quiet archive of last-known positions.

Applicable and Non-Applicable Scenarios

Live location in a group is well suited to situations where a small number of people, all of whom have agreed to be visible, need mutual awareness for a bounded period. A three-person airport pickup, a two-person equipment handover, a small event crew coordinating across a venue, or a hiking group where everyone shares for the duration of the walk — these are the natural fits. The common characteristics are short duration, mutual visibility, and no expectation of a permanent record.

It is a poor fit when any of four conditions holds. When the organisation needs a historical record of movement over days or weeks, because the feature produces last-known positions rather than histories. When the group is large and open, because every member — including anyone who joins later and scrolls back — can see the marker and the residual message. When the tracking is one-directional and non-consensual in spirit, such as a manager monitoring a subordinate's movements, which is a policy question before it is a technical one. And when the environment is a broadcast channel audience rather than a working group, because the posting model does not apply.

A useful admission test before enabling the workflow: can you describe, in one sentence, who is entitled to see the position, for how long, and who removes the message afterwards? If any of the three answers is "we'll figure it out," the group is not ready, and a static check-in convention will serve better until the policy is written.

Best Practices Checklist for Audit-Friendly Groups

The following rules are ordered by how much they reduce risk per unit of effort. The first three are nearly free; the rest assume the group has a coordinator role.

  • Default to the shortest duration. Re-share instead of extending. A lapsed share costs seconds; a day-long trace costs context you cannot recover.
  • Announce the share in text. One line before the map message, naming the person, the purpose, and the intended end time, so the chat reads as a log rather than a sequence of unexplained maps.
  • Delete expired messages. Assign the sweep to one named role, typically an administrator with delete rights, so the action is attributable in the admin log.
  • Pin only while active. Pinning solves the scroll-away problem; leaving old pins in place recreates the clutter you were avoiding.
  • Keep the group membership tight. Every member is a potential viewer of every historical position. Review the member list on the same cadence as the retention sweep.
  • Record your verification results. One page per platform, updated after major client releases, is worth more than any external summary — including this one.
  • Treat screenshots as out of scope for technical controls. No setting prevents a camera photographing a screen; if a position must not be photographed, it must not be displayed.
  • Do not log coordinates outside Telegram without a retention plan. An external log inherits every obligation the chat did not have.

The list is deliberately short. Long checklists get partially followed, and a partially followed retention process is worse than a simple one that actually happens.

Risks, Boundaries, and Honest Limits

Three limits deserve to be stated without hedging. First, live location is not a security control. It does not verify identity, it does not prove a person was somewhere, and a device can be handed to someone else. Any process that treats a moving pin as evidence of presence is over-reading the data.

Second, the residual last-known position is a real disclosure, not a theoretical one. Assume that any live location ever shared in a group will remain visible to every member of that group until someone deletes it, and design accordingly. Deleting promptly, keeping membership tight, and using short durations are the three levers you actually control.

Third, the platform evolves. Menu labels, preset durations, deletion windows, and background update behaviour have all changed over Telegram's history, and they will change again. Everything in this article is written to be re-verified rather than cited, and the four tests in the verification section exist precisely so that your team can re-establish ground truth in ten minutes after any major update. Where the article says the latest version as of this writing, read it as a timestamp on an observation, not as a permanent specification.

Frequently Asked Questions

Does a Telegram live location disappear when the timer ends?

No. The updates stop when the countdown finishes, but the message itself normally remains in the chat showing the last recorded position, until the author or an administrator with delete rights removes it. Verify this in a two-person test group by sharing the shortest available duration and checking the message after it expires.

Can a group administrator delete someone else's live location?

In groups, an administrator holding delete-messages permission can generally remove messages authored by other members, including location messages. The exact behaviour and any timing limits should be tested in your own group, because deletion windows have been adjusted by Telegram over time and may differ between your own message and someone else's.

Does a live location keep updating if I close the Telegram app?

Update reliability when the app is closed or backgrounded varies by platform, operating-system permission mode, and battery settings, so it should be measured rather than assumed. A practical test is to share for about an hour, close the app for several minutes, and ask a colleague whether the marker moved during that window.

Is there a group permission toggle that specifically blocks location sharing?

Current clients do not appear to offer a permission labelled specifically for live location. Administrators generally have to rely on broader posting or media restrictions, and whether those restrictions also suppress the location attachment option is best confirmed empirically in a sandbox group before you depend on it.

Can a bot post and update a live location in a group?

Yes. The Bot API documents methods for sending a location with a live period, editing a live location, and stopping it, which suits shared assets such as vehicles rather than people. Check the current Bot API reference for parameter bounds and method names, and remember that if you log the coordinates yourself, you take on the retention obligations for that log.

Where to Go From Here

Telegram live location in group chats is a small feature with a long tail. The sharing itself takes seconds; the decisions that matter are the ones around it — which duration, who may see it, who removes the residual message, and how you confirm any of this after the next client update. If you take one action away from this article, make it the expiry test: two people, one short share, and a note about what remains afterwards. That single observation will tell you more about your retention exposure than any general guidance.

From there, write down three things for each group that uses the feature: the shortest duration that covers the task, the named role responsible for the post-expiry sweep, and the date your team last re-ran the four verification tests. Keep that note short enough that someone will actually maintain it. And whenever a client update lands, re-check the two things most likely to have moved — where the live option appears in the map picker, and what your group's Recent Actions view records about deletions.

Version Expectations

It helps to expect drift rather than to be surprised by it. Based on the pattern observed over past releases, the entry point to live sharing, the wording of the duration presets, and the deletion window available to authors and administrators are all areas that may change between builds without any announcement aimed at group administrators. This is an empirical observation rather than a forecast of specific upcoming changes, and no dates or version numbers should be inferred from it. The practical response is procedural, not predictive: keep your one-page verification record dated, and treat every point in this article that is marked as observed behaviour as something to re-confirm rather than to quote. A workflow built on three checks — the entry path, the expiry behaviour, and the deletion rights — will survive most client updates intact, because those three cover the parts of the feature that carry retention consequences.

Related reading