Limerino Privacy Policy

Limerino is a native iOS Twitch chat client. This document describes exactly what data the app handles, where it lives, and who it is shared with.

If anything below is unclear or you'd like a copy of your data, contact hello@meipath.com.

TL;DR

Limerino has no advertising SDKs and no trackers, and Limerino itself collects no analytics about you. Live video is the one exception, and it is named here: two reports go out while a live stream plays on the Native player. First, streams play through the Amazon IVS Player, the same engine Twitch’s own player uses, and that engine sends its own playback report to player.stats.live-video.net while a live stream is playing. The engine’s privacy manifest declares five kinds of data the engine collects: an identifier the engine assigns to the viewing session (listed under Apple’s User ID category), the interactions you make with the player, performance figures such as buffering and bitrate, other diagnostic details about the playback, and a residual category the manifest lists only as "other data types" — collected for the engine’s own analytics and to make playback work. That collection is Amazon’s, for the Amazon-owned engine that also powers Twitch’s own player — not Limerino’s: Limerino’s servers never receive it. It is not linked to your identity, is never used for tracking, and happens only while a live stream is playing on the Native player. Second, while a live stream plays on the Native player and is on screen, Limerino tells Twitch once a minute that you are watching that channel — the same watch-time report Twitch’s own player sends, so your watch time and channel points count as they do on twitch.tv. It carries your Twitch user ID, the channel, the stream and its category, whether the player is muted, and the time, with the same identification the Native player’s other Twitch requests carry (the app’s name and version, your iOS version, a session identifier the app makes up each time it starts, and the device identifier Twitch itself set in the player’s web session); it goes only to Twitch, over the player’s Twitch web session described under Twitch authentication, never to a Limerino server, and nothing is sent while the stream is paused, buffering, covered or in the background. Choosing Embedded under Settings → Video → Player type plays live streams through Twitch’s own web player instead, and both reports stop with it — Twitch’s player then reports to Twitch as it does on twitch.tv, within that same Twitch web session. Beyond them, Limerino uploads nothing about you or your activity except in situations you start yourself: signing in with Twitch, which establishes your mention-alerts session (see below); turning on mention alerts (same section); turning on live alerts for a channel, or for all of them (same section); turning on Twitch badge alerts, or changing that setting later (same section; while you are signed in, the app also asks for that setting each time it opens or comes back to the foreground, a request that carries only your mention-alerts session); sending feedback from Settings — Report a Bug or Suggest a Feature — both described under Bug reports & feature suggestions; linking a Discord account, if you choose to (see Discord account linking); choosing which Limerino badge shows beside your name, or none (see Limerino chat badges); choosing which Twitch badge you wear, everywhere or in one channel, which sends your choice to Twitch over the player's Twitch web session, never to a Limerino server (see The Twitch badge you wear); linking a 7TV account, if you choose to, which lets you change the emotes and emote sets of your own channel and of any channel that has made you a 7TV editor, and choose the 7TV name paint your own name is drawn in and the 7TV badge shown beside it — every one of those changes is a write you make yourself, and it carries a 7TV sign-in token kept in this device's Keychain; searching that feature's emote directory, which sends the words you type to 7TV, carrying no token (see 7TV account linking); linking a StreamElements account, if you choose to, which lets you see and change the settings of the StreamElements chatbot in your own channel and in any channel where StreamElements gives you a Bot Supervisor, Editor or Full Control role — every change is a write you make yourself, and it carries your StreamElements sign-in token, kept in this device's Keychain, or a manager session obtained with it; finishing a link and renewing it go through Limerino's server, which keeps no StreamElements token, and while Show bot controls in chat is on, the app reads your StreamElements roles the first time chat opens after the app starts or you sign in (see StreamElements account linking); attaching or pasting an image in chat, which sends that image to the image host under Image uploads — available unless you turn it off, and it sends nothing until you attach or paste something yourself (see Image uploads); acknowledging a moderator's warning, which sends that to Twitch over the player's Twitch web session, never to a Limerino server (see Your standing and chat access in a channel); following or unfollowing someone, or claiming a watch bonus, which sends that one request to Twitch from Twitch's own page in the app, over the player's Twitch web session, never to a Limerino server (see Follow, unfollow and the watch bonus); opening Channel Points or redeeming a reward, which sends those requests to Twitch over the player's Twitch web session, never to a Limerino server, and watching another channel's chat when Limerino can't check its predictions (with Predictions off, for example), which asks for your balance and the channel's rewards the same way, so your balance can show at the top of chat (see Channel Points); sharing a resub in chat from Channel Points, which Twitch then posts in that channel's chat (see Sharing a resub in chat); watching another channel's chat, opening Predictions there, placing your points on a prediction, or running one as that channel's moderator, which sends those requests to Twitch over the player's Twitch web session, never to a Limerino server (see Predictions); voting in a poll from its sheet, which sends your vote to Twitch over the player's Twitch web session, never to a Limerino server (see Voting in a poll); starting or ending a poll as a channel's moderator, sent the same way (see Polls you run as a moderator); opening Moderation history on a chatter's card in a channel you moderate (see Moderator history on a user card), opening your Twitch badge from the Badges screen (see The Twitch badge you wear), and opening Whispers or a whisper conversation (see Whispers / direct messages), each of which sends its request to Twitch over the player's Twitch web session, never to a Limerino server; adding or deleting a moderator comment on a chatter's Moderation history, sent the same way (see Moderator history on a user card); and opening a channel, which (like in every Twitch chat app) sends that channel's public identifiers to Twitch and to the third-party emote/badge providers so their emotes and cosmetics load and, with no token and nothing about you, its pinned message, poll, reward names and chat rules unless you turn them off in Settings, and whether a Hype Train is running once you turn Hype Train on there (see A channel's public chat details), and asks Twitch, over the player's Twitch web session, whether you can chat there and whether a moderator warned, timed out or banned you there (see Your standing and chat access in a channel). While you are signed in, requests to Twitch carry your Twitch sign-in token, because that is how Twitch authenticates you, or, for the requests named under Twitch authentication, the player's Twitch web session instead; those public chat details carry neither; the third-party emote/badge providers receive no token and no identifier of yours for the emote, badge and cosmetic requests every user makes, though if the channel you open is your own, its channel id is by definition your public Twitch account id. There are two exceptions. While you are signed in with Show badges and BetterTTV global badges on, Limerino tells BetterTTV your Twitch user ID with each channel you open, so BetterTTV Pro badges can show (see the BetterTTV bullet below). And a 7TV account you link yourself: the requests that read your 7TV identity and make the emote, name-paint and 7TV badge changes you ask for carry your 7TV sign-in token, because that is how 7TV authenticates you (see 7TV account linking, and the network table under How the data leaves the device). Requests to StreamElements go out only for a StreamElements account you link yourself, and carry that account's StreamElements sign-in token, or a manager session StreamElements issues for a channel you help manage (see StreamElements account linking). The Limerino-operated endpoints it touches are a small sign-in bounce page (limerino.com/oauth/callback) and the backend at api.limerino.com. The bounce page belongs to the app's legacy web sign-in path; the current sign-in doesn't open it, and if that path ever runs, the token rides the URL fragment, which that server never receives (see Twitch authentication). The backend is contacted when you sign in, each time the app opens or comes back to the foreground while you are signed in (to keep your unread-mention count right, which it also does about ten seconds after you read a mention while the app is open and when you leave the app with a read it has not reported yet — see Mentions & highlights Inbox — and to read your Twitch badge alert setting), while mention alerts, live alerts or Twitch badge alerts are on (see Mention alerts & Mention Vault), when you change a highlight rule's alert word while mention alerts are on, when you tap a chatter to see their recent messages (same section), when you send feedback — a bug report or a feature suggestion (see Bug reports & feature suggestions) — or when you link, check, or unlink a Discord account (see Discord account linking), or link a StreamElements account or renew its access (see StreamElements account linking). It is also contacted at app start, signed in or out, to fetch the public chat-badge list, and again later to keep that list current; for a badge's images when one is drawn; and while you have chat open, or watch a video or clip with its chat replayed (signed in or out), to ask which Limerino badges the people chatting there show — and, when you open Badges, while your linked Discord account is on screen (your profile, or Settings → Discord), or just after you link or unlink a Discord account, which ones you show. Those lookups send numeric Twitch user-IDs, in batches, with no token and nothing else about you (see Limerino chat badges). Which badges you hold, and which one you chose to show, are read with your mention-alerts session instead: when you open Badges, and again just after you link or unlink a Discord account if you have opened it since the app started. Your choice, when you make one, is sent the same way (same section). When you open Badges or Earnable now, the app also reads your own Twitch badges and the list of Twitch badges that can be earned right now, with your mention-alerts session, which identifies you to the server, and nothing else about you; to answer, the server reads your badges from Twitch by your Twitch username (see Twitch badges you can earn, and the ones you have). Reporting objectionable chat is handled by Twitch — the in-app Report action opens the reported user's Twitch page, where Twitch's own reporting controls are, and Limerino keeps no copy of reports (see Reporting below).
Signed-out mode preserves saved channel tabs and messages on your device. Limerino makes no Twitch chat connection until you sign in. Public global-emote catalogs from 7TV, BetterTTV, and FrankerFaceZ, and Limerino's own public chat-badge list, can still load at app start; the exact destinations and data sent appear in the network table below.
Signing in stores your Twitch login and tokens (access + refresh) in the device Keychain so the app can send chat, fetch your follows, use moderator tools, and keep you signed in between launches. Those tokens never leave the device except to talk to Twitch's own APIs — and the identity check that establishes your mention-alerts session, described under Mention alerts & Mention Vault. A 7TV account you link yourself keeps its own separate token, which goes to 7TV and nowhere else (see 7TV account linking). A StreamElements account you link yourself keeps its own tokens too; they go to StreamElements, and to Limerino's server only to be renewed, which keeps no copy (see StreamElements account linking).
Limerino cannot delete data that Twitch holds. Limerino is a third-party Twitch client: your Twitch account, the messages you send, your follows, and your watch activity live on Twitch's servers under Twitch's own privacy policy. Deleting your Limerino data removes nothing from Twitch — use Twitch's own controls for that (see Removing your data).
Chat history stays on your device for scrollback: every channel you open is appended to a per-channel JSONL file under the app's Documents folder, and that file never leaves the device. Tapping a chatter is the one exception — their recent messages in that channel can be served from a Limerino server cache that holds up to the last hour of public chat in memory only (see Mention alerts & Mention Vault).
When you're signed in, your Twitch whispers (DMs) and your mentions / highlights Inbox are saved on the device so they survive a relaunch. Opening Whispers also brings in your recent conversations from Twitch, saved the same way. Turning off Load earlier whispers in Settings stops that. These saved copies are owner-scoped, never shared between accounts, and never uploaded as a database; the app does tell Limerino's server which Inbox entries you have read, by Twitch message ID only (see Mentions & highlights Inbox). Sending a whisper transmits its text and the sender's and recipient's Twitch IDs to Twitch. Clear the saved copies in the app, remove the account from this device, or uninstall, to delete them; signing out hides them but keeps each account's saved copy on the device for when you sign back in (see Removing your data).
What you keep on this device belongs to your account. Signing out, or switching to another account, keeps your settings, open channels, chat logs, whispers and Inbox on this device for that account alone: no other account sees them, and signing back in brings them back. Removing the account from this device (Settings → Accounts) deletes them (see Removing your data).
After you sign in, scrollback from before you joined a channel can be fetched from recent-messages.robotty.de (a third-party, public API). You can turn it off in Settings.
When you tap a chatter's name, the user card can show how long they have followed the channel you are watching and their public subscription standing there. The subscription answer comes from api.ivr.fi, a third-party community service — the request carries that chatter's public Twitch name and the channel's, and nothing else. The follow answer comes from Twitch's own API, using your signed-in session, and only where Twitch lets you ask — about yourself, or about a chatter in a channel you moderate (see Follow & subscription details on a user card).
Pronouns are off unless you turn them on. With Show pronouns on user cards or Show pronouns in chat on, Limerino looks up the pronouns people have published with api.pronouns.alejo.io, a third-party community service, sending only the public Twitch username of each person it looks up (see Pronouns).
When someone sends a GIF in chat, your device loads that picture from GIPHY, which hosts the GIFs Twitch's built-in GIF feature delivers. The request carries the address Twitch supplied and nothing about you. Show GIFs sent in chat is on unless you turn it off; with it off, the GIF arrives as the short description Twitch sends with it and GIPHY is never contacted (see GIFs sent in chat).
While BetterTTV badges are on and you're signed in, Limerino tells BetterTTV your Twitch user ID and the channel you open, so your BetterTTV Pro badge can show to you and to other BetterTTV users in that channel, and other people's Pro badges can show to you. BetterTTV global badges is on unless you turn it off, and this needs Show badges and BetterTTV emotes on too; turning any of them off stops it (see sockets.betterttv.net under How the data leaves the device).
Sharing, widgets, and Siri stay on your device. Channels you share into Limerino, pin to a home-screen widget / Live Activity, or open via the Siri shortcut are passed between Limerino's own app extensions and the main app through a private on-device container — nothing is uploaded.
Bug reports and feature suggestions are optional, user-initiated uploads. The policy below lists the exact text, device metadata, optional diagnostics, and server-side processors involved.

What Limerino collects, where it lives, and why

Twitch authentication (only when you sign in)

When you tap Sign in with Twitch in Settings → Account, the app starts Twitch's device-code flow: it shows you a short code and opens Twitch's own activation page (www.twitch.tv/activate) in a secure in-app web view (WKWebView). If that page needs you to sign in, it routes through Twitch's own login page (www.twitch.tv/login) — you enter your credentials on Twitch's pages, not in Limerino. You can approve in your system browser instead (Use browser instead — the path passkey sign-ins need). On success Twitch returns:

your Twitch login (username) and user-ID
an OAuth access token with the scopes you granted
a refresh token, which lets the app renew the access token so you stay signed in without repeating the login

Per signed-in account, the Keychain holds: the access token, the refresh token, your login, the granted scopes, the token expiry, and a pointer to which stored account is currently active. All of it lives in the iOS Keychain with kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly, scoped to this device, non-syncing. The tokens are sent only to Twitch's official APIs (api.twitch.tv, id.twitch.tv, eventsub.wss.twitch.tv, irc.chat.twitch.tv) — with one exception you opt into by signing in: when the app establishes your mention-alerts session, the access token is also sent to api.limerino.com, where the server checks it against Twitch to confirm who you are, then discards it. It is never stored (see Mention alerts & Mention Vault). In return the server issues the app a session for that account, which the Keychain keeps the same way. The app sends it only to api.limerino.com, gets a new one when it stops working a day after it is issued, and keeps it after you sign out (see Removing your data).

The in-app approval page shares its web storage with the in-app video player, so the one Twitch login you perform there also signs the video player in. That player session is a Twitch web session cookie: a separate credential issued and controlled by Twitch, stored in the player's WebKit website storage on this device, never in Limerino's own storage. It is sent only to Twitch — to Twitch's web pages the way any browser cookie is, and to Twitch's own token-check endpoint (id.twitch.tv) once per established player session, again after any sign-in you make in the app, again before a Channel Points, Predictions, moderator history or Twitch badge request, or a change you make on Twitch from Limerino and the reads that go with it, when your sign-in or the web session has changed since the last check, and again if Twitch answers one of those requests as a different account (see How the data leaves the device), which is how the app verifies that the session belongs to the same Twitch account you signed into. The Native player's own requests to Twitch — the playback request made when a live stream starts, or when a clip or past broadcast starts in Limerino's own player, and the watch-time report named in the summary — and the Channel Points and Predictions requests, the reads of your chat access and standing in a channel, and the moderator history, Twitch badge and whisper history reads (see Channel Points, Predictions, Your standing and chat access in a channel, Moderator history on a user card, The Twitch badge you wear and Whispers / direct messages) present that session together with the device identifier Twitch itself set in the same web storage, the app's name and version, your iOS version, and a session identifier the app makes up each time it starts; the Embedded player sends the same cookies from inside Twitch's own page, and so do a follow, an unfollow and a watch-bonus claim, which Limerino sends from Twitch's own page (see Follow, unfollow and the watch bonus). The session is labeled unverified when that check cannot complete, and cleared if it provably belongs to a different account. Limerino never writes the cookie's value into logs, reports, or its own storage. For a follow, an unfollow or a watch-bonus claim, and nothing else, Twitch's own page in the app performs Twitch's integrity check, and the request carries the integrity token it gets, which never leaves that page; no other request Limerino sends carries the token or asks Twitch for one. Turning off Web features under Settings → Account → Advanced → Choose permissions stops every read and every change Limerino would send for follows, polls, predictions, Channel Points, chat access, standing, moderator history, your Twitch badge and whisper history, along with a channel's other public chat details, and hides what they show; the video player, chat replay, and what you send through your Twitch sign-in (chat messages, moderation, creating clips, and your own channel's poll and prediction tools) are not part of it.

Chat replay for VODs and clips. When you play a past broadcast (VOD) or a clip in the in-app theater, Limerino replays that video's chat beneath the player by fetching the video's past chat messages from Twitch — read-only, using this same player web session so replay behaves like watching the stream live (if that player session is missing, or Twitch refuses it, the same request is retried with no credential at all). Limerino stores none of the fetched messages, and can turn this feature off remotely from its own server without an app update.

Every sign-in — including Sign in again for new features and adding another account — uses this same device-code flow; no OAuth redirect is involved. The app also keeps a small Limerino-operated bounce page registered as its OAuth redirect at https://limerino.com/oauth/callback (a static page on a Railway service, Cloudflare-fronted) for its legacy web sign-in path, which the current sign-in flow does not open. If that path runs, its only job is to forward the result back to the app's limerino://oauth/callback scheme; the access token travels in the URL fragment (the part after #), which browsers keep client-side and do not send to the server — so the page returns the sign-in to the app without the limerino.com server receiving your token. It runs no analytics and sets no cookies of its own.

To remove: Sign out (which also clears the video player's Twitch web session), or uninstall the app — see Removing your data below.

Chat logs (Documents/Limerino/Logs/)

Every channel you open writes its chat to a file of its own, <channel>.jsonl, in a folder under <Documents>/Limerino/Logs/ that belongs to the account you are signed in with (signed out, the device has a folder of its own). Each line records the message ID, sender login, display name, body, and timestamp. This is local-only — the file never leaves the device. That is a claim about this log, not about chat in general: the recent-messages cache described under Mention alerts & Mention Vault holds up to an hour of public chat on a Limerino server, in memory, and the app reads from it when you open a chatter's card.

To remove: Delete a channel's log in the app — Settings, then Channel logs: swipe the channel (or tap Edit) and confirm, or open the channel's log and choose Delete this log. That removes the .jsonl file and any export saved beside it. Channel logs lists the logs of the account you are signed in with. Signing out keeps an account's logs on this device for its next sign-in; removing the account from this device deletes them, and uninstalling the app removes them all — see Removing your data below.

Open channels and settings (SwiftData)

Your open channel tabs, custom commands, mod actions, blocked users, muted phrases, theme choice, and other preferences are persisted via SwiftData in the app's sandbox. Local-only, with three exceptions: blocking a user also mutes that user's mention notifications, which adds their login to your muted senders (synced as described under Muted-sender sync below); the channels you turn live alerts on for sync as described under Live-alert channels below: with All channels on, that is every Favorite and open tab, including ones you add later; and, while Mention push alerts are on, single words from your highlight rules sync as described under Alert keywords below. The rules themselves stay on this device.

While you are signed in, all of this belongs to your account. Signing out, or switching to another account, keeps it on this device for that account alone, and signing back in brings it back; signed out, the app uses a separate set of its own. Two settings belong to the device and are the same for every account: Siri & Search and Player type.

A photo you choose as a chat background is copied into the app's storage on this device, without its location or camera details, and is never uploaded. Removing the background deletes the copy; so does removing the account that set it.

To remove: Remove the account from this device (Settings → Accounts) to delete what it kept, or uninstall the app to delete everything — see Removing your data below.

Whispers / direct messages (SwiftData, only when you're signed in)

When you are signed in, the Twitch whispers (direct messages) you send and receive through Limerino are saved to a private, owner-scoped SwiftData store on the device, so your conversations are still there when you relaunch. They are keyed to your Twitch user-ID, are never shared between accounts, and never leave the device except as the whisper itself travels over Twitch's own API.

Sending a whisper sends its text, your Twitch user-ID and the recipient's Twitch user-ID to Twitch, which handles delivery and retains messages under its own privacy policy. Limerino's backend receives no copy of the whisper.

History from Twitch. When you open Whispers, Limerino also asks Twitch for your 20 most recent whisper conversations, at most once every five minutes, and once more when Try again brings whispers back after they stopped arriving. When you open a conversation, it asks for that conversation's latest 50 messages, at most once a minute for it.

Nothing is asked at launch, in the background, for a conversation that is not on screen, while you are signed out, or when you turned off whispers under Choose permissions. Turning off Load earlier whispers in Settings stops both requests and keeps the whispers already brought in. These requests go to Twitch over the player's Twitch web session (see Twitch authentication), never to a Limerino server, and only when the video player's account check has shown that the web session belongs to the Twitch account you use in Limerino. Each carries the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token; the request for one conversation names it by your Twitch user-ID and the other person's. What Twitch sends back is saved in the same store, exactly like whispers you receive, up to 500 messages a conversation: never from someone you blocked, and never shown as a new message, a notification or a line in chat. Twitch's unread count decides which fetched messages start unread; after that, your reading in Limerino does. Conversations you archived on Twitch are left out, a message deleted on Twitch is removed here too, and an edited one shows its new text.

To remove: Whispers → Clear deletes them from the device, the ones fetched from Twitch included, as do removing the account from this device and uninstalling the app; deleting a conversation removes that conversation. A deleted conversation, or a Clear, keeps only the time you removed it, so Limerino never fetches those messages again; removing the account deletes that time too. Twitch keeps its own copy either way. Signing out hides them and stops new ones, but keeps this account's saved whispers, fetched ones included, on the device for when you sign back in — use Clear, remove the account, or uninstall to delete them. (See Removing your data.)

Mentions & highlights Inbox (SwiftData, only when you're signed in)

The Inbox collects messages that mention you or match your highlight rules so you can find them later. Each saved entry — the message text, who sent it, the channel, and a timestamp — is written to a private, owner-scoped SwiftData store on the device, capped to a recent window. The entries themselves never leave the device, but whether you have read them does: while you are signed in, each time the app opens or comes back to the foreground, about ten seconds after you read a mention while the app is open, and when you leave the app with a read it has not reported yet, it sends Limerino's server the Twitch message IDs of Inbox entries from the past seven days that you have read, over your mention-alerts session, so the server can mark its own copies of those mentions in your Mention Vault as seen and your unread-mention count stays right. Only the IDs are sent, never the text, who sent it, or the channel, and the server keeps no list of them.

To remove: Clear it from the Inbox to delete the saved entries, remove the account from this device, or uninstall the app. Signing out hides the Inbox but keeps this account's saved entries on the device for next sign-in — use Clear, remove the account, or uninstall to delete them.

Mention alerts & Mention Vault

Mention alerts and the Mention Vault are the app's server-side features, served by the Limerino backend (api.limerino.com, hosted on Railway). Two different things reach that server, at two different times.

When you sign in, the app establishes your mention-alerts session, whether or not you use mention alerts, and renews it the same way whenever it lapses, at the next request that needs it. Your Twitch access token is sent to the server, which checks it against Twitch to confirm who you are and then discards it — it is never stored. The server keeps an identity row for you (your Twitch user-ID, login and display name, and your mention-alert entitlement state) and, so mention alerts can work, watches public Twitch chat across the channels our monitoring network covers for messages that mention your username. Two things come out of that watching: each match is stored server-side in your Mention Vault so an alert can reach you even when Limerino isn't open, and the public messages it passes over are held briefly in a memory-only cache keyed by chatter rather than scoped to your Limerino account. What the server holds:

Mention Vault — for each message that mentions you: the message text and id, the channel and its Twitch channel-ID, the chatter's public Twitch login, display name and user-ID, their name color and badges, which emotes the message used, a timestamp, and — when the message carried a GIF sent through Twitch's built-in GIF feature — Twitch's GIF tag exactly as it supplied it: the picture's address, its GIPHY id, and where the caption sits in the message.
Recent-messages cache (not account-scoped) — for each public message in a monitored channel: the channel, the chatter's public Twitch user-ID, the message id, when it was sent, the text, and the chatter's login, display name, color, and which emotes it used. Held in memory only for up to the configured window — one hour by default — and then dropped. It is never written to disk, and a server restart wipes it. It exists to power the user card's recent messages, described below, and nothing else.
Blocked-user sync (optional) — if you use Twitch's block list, your blocked-user IDs can be synced to the server so a blocked chatter never generates a match or a vault entry.
Muted-sender sync (optional) — if you mute a user for notifications (from a push action, from Notification settings, or by blocking them anywhere in the app — a user card, a report sheet, a whisper conversation, or Settings → What you see → Blocked users & muted phrases), that user's Twitch ID (or login) joins your muted senders and syncs to the server with the rest of your mention-alert settings, so their mentions never alert you. Importing a settings file that carries blocked users adds those to the same list. Clearing your mutes — or unblocking the user — syncs the removal the same way.
Followed-channel list — once you open Notification settings or turn on mention alerts, the server stores the login names of the Twitch channels you follow (synced from your device), so alerts default to the channels you actually watch. The channels you get mention alerts for also tell Limerino's monitoring which channels to join: it reads their public chat like that of every other monitored channel, so a mention in a small channel can still reach you, and that chat passes through the memory-only recent-messages cache above.
Notification preferences — your per-channel alert toggles, same-sender cooldown, batch window, quiet hours and time zone, delivery mode (real-time or summary), whether replies to you alert, and whether a mention must spell your name with its exact capitals (Match case), so the server knows which mentions to keep and which pushes to send and when.
Alert keywords (optional) — while Mention push alerts are on, up to ten single words from your own highlight rules are stored with your account: each comes from a Phrase rule you set to send a System notification, so a message containing that word, in a channel you get mention alerts for, can alert you even when Limerino is closed. Only the words are stored — never who sent a message. Each device keeps its own list, saved with a random ID Limerino creates on that device and keeps in the device's Keychain (it stays the same if you reinstall the app on that device, never moves to another device, and is not an advertising identifier), and the ten are counted across all your devices. Rules that match a username, a regular expression, or more than one word never leave your device, and very common words and your own username are refused. The server counts how often each word matches in the past hour, and pauses a word that matches too often for a day. Changing or removing the rule updates that device's list, and on that device turning Mention push alerts off or turning Phrase matches off in Activity alerts empties it. Signing out does not: the list stays with your account, so its words can still alert your other devices. The server deletes a device's list once that device has not confirmed it for 30 days — after you sign out there or delete the app, for example.
Live-alert channels (optional) — if you turn on live alerts for a channel, or for every channel in your list (All channels: your Favorites and open tabs, including ones you add later), the server stores those channels' Twitch IDs and names and your live-alert choices (which alerts, whether they make a sound, and how they are grouped), and registers this device's push token to receive them, whether or not mention alerts are on. It checks whether those channels are live about once a minute with Limerino's own Twitch credential — never your Twitch token — and keeps each channel's latest live status, not linked to you, so an alert fires once per stream. Only the channels you turned on are stored; turning one off removes it. Signing out does not remove them: they stay with your account for your other devices and your next sign-in.
Twitch badge alerts (optional) — if you turn on Twitch badge alerts in Activity alerts, the server stores which ones you want — for badges you get by watching or clipping, and for badges that need a sub, gift sub or Bits — as two on/off settings linked to your Twitch user ID. It also registers this device's push token to receive these alerts, whether or not mention alerts or live alerts are on. Turning either one on or off sends the new settings the same way. The choice stays with your account until you delete your server data or the 90-day idle clean-up removes your account: turning both off stores them as off, and signing out does not remove them. Turning both off removes this device's push token unless mention alerts or live alerts still use it, and signing out removes it right away. While you are signed in, the app asks the server for this choice each time it opens or comes back to the foreground, whether or not you ever turned these alerts on; that request carries only your mention-alerts session. An alert tells you when a badge of a kind you turned on can be earned and your Twitch badge collection doesn't have it, or when you earn one. Which badges can be earned comes from Twitch's public list of chat badges, which the server reads with Limerino's own Twitch credential, and from public information about when each can be earned: none of it holds anything about you, and nothing you watch or say in chat decides who gets an alert. To know which badges you have, the server reads your Twitch badges and keeps their ids (see Twitch badges you can earn, and the ones you have): turning a switch on while both were off starts that read, and while either switch is on and a device of yours takes these alerts, the server reads them again about once a day. During your quiet hours, if you set them, these alerts arrive without a sound. For each badge that could be earned when you turned these alerts on, each one an alert told you about, and each one your collection already held, the server keeps a record of your Twitch user ID, the badge and when, so the same badge is never announced to you twice; these records are deleted with your Twitch badge ids (see Retention below).

Recent messages on the user card. Chat messages from the public Twitch channels that monitoring already covers are also held in memory only, for up to one hour, filed under the chatter's public Twitch user-ID, so tapping someone in the app can show what they said recently in that channel. Nothing is written to disk and every message expires automatically. You are a chatter too, so your own public messages in those channels sit in that cache the same way anyone else's do — what the cache does not do is link any of it to your Limerino identity row, your Mention Vault, or any record of whose card you opened. Opening a card sends the channel and that chatter's public Twitch user-ID over your mention-alerts session, which identifies you to the server — nothing else about you.

Turning mention alerts on registers this device to receive those alerts: it stores this device's APNs push token so the server can notify you. Live alerts and Twitch badge alerts use the same token (see Live-alert channels and Twitch badge alerts above). Turn mention alerts off and that push token is removed right away, unless live alerts are still on for a channel or Twitch badge alerts are on: then it stays registered for those only, until you turn them off too. Sign out and it is removed right away either way. Uninstalling cannot remove it — iOS runs no app code when you delete an app — but no alert can reach a deleted app, and the token is pruned automatically the first time Apple reports it as gone. Either way, no alert is delivered to this device. Turning alerts off stops delivery, not the server-side watching — to stop that and clear the Mention Vault itself, use the in-app delete (To remove below), which removes it right away, or leave the account idle for the 90-day reap. The separate, user-initiated feedback upload is described below.

Retention — what Limerino deletes, and when. The server deletes the data above on its own, without you asking:

Idle accounts — 90 days. If your account has no mention-alert entitlement recorded and has gone idle for 90 idle days — no sign-in and no device check-in in that time — the server deletes your identity row, and with it your Mention Vault entries, your device push token, any synced blocked-user IDs, your synced muted-sender list, your alert keywords, your live-alert channels and choices, your Twitch badge alert choice and its records, the Twitch badge ids kept for you, your followed-channel list, and your notification preferences.
Vault ceiling. Your Mention Vault is capped; once it is full, the oldest entries are trimmed away as new ones arrive.
Recent-messages cache — one hour. A cached message drops out of the memory-only recent-messages cache once it is older than the configured window — one hour by default — and because the cache is never written to disk, a server restart wipes all of it at once. The in-app delete does not reach it: your own cached messages, like every other chatter's, expire on that clock.
Your Twitch badges — a day, or while a badge alert is on. The ids of the Twitch badges the server read for you are deleted once both Twitch badge alert switches are off and a day has passed since the last read; while either is on, they stay and are read again about once a day. The records of your Twitch badge alerts are deleted with them. Both go when you delete your server data or the idle clean-up removes your account. The three badge counts kept under your Twitch username are deleted once they have not been read for 30 days (see Twitch badges you can earn, and the ones you have).
Bug reports and feature suggestions — 180 days. A submitted support request is deleted from Limerino's backend 180 days after you send it, whatever its status — the typed description, the device metadata, any diagnostics you included, and the salted hash of the connection's IP address. When a request was kept for follow-up, the copy in the developer's private issue tracker is the record that remains — and so is its thread in the public Limerino Discord community, which this window does not delete and which keeps whatever username the post credited you with; see Bug reports & feature suggestions. Anthropic's copy of what it received for triage follows Anthropic's own schedule: deleted within 30 days unless it needs it longer to enforce its usage policy or to comply with the law.
Chat badges the Limerino team gave you — no idle clock. A badge the Limerino team gave you is not removed by the 90-day idle clean-up: the server keeps your Twitch user-ID, the Twitch username it matched, the optional note, who gave it and when (and whether it was an exception to the badge's usual rule) until the badge is revoked or deleted, or you delete your server data (Settings → Mention Vault & data → Your data). The change-log entries naming you are kept until you delete your server data. Your choice of which Limerino badge shows (your Twitch user-ID, the badge you picked or None, and when you chose) is deleted by the idle clean-up unless you still hold such a badge; then it stays until you no longer do, so a None choice keeps that badge hidden. Deleting your server data deletes it either way. A badge earned by a rule is different: it ends when the idle clean-up removes your account (see Limerino chat badges).

Backups. Limerino's backend database is backed up daily so it can be restored after a failure. A deletion — automatic or one you ask for — removes your data from the live database immediately; a copy can persist in those backups for up to 30 days, after which the backup containing it is destroyed on a rolling schedule. Backups are used only to restore the service, are never queried to answer anything about you, and are never shared.

You do not have to wait for the idle reap or the vault ceiling: To remove below deletes the same data on demand, and Removing your data covers everything on the device.

What Limerino cannot delete: anything Twitch holds. Limerino is a third-party Twitch client. Every rule above is about data Limerino's server holds. Your Twitch account, the chat messages you send, your follows, and your watch activity are Twitch's records, kept on Twitch's servers under Twitch's own privacy policy and retention rules. Limerino cannot delete data that Twitch holds, and none of the deletions above touch it — use Twitch's own controls for that (see Removing your data).

To remove: while signed in, open Settings → Mention Vault & data → Your data to delete your Mention Vault entries, or all server account data (mentions, device, and entitlement state, plus your followed-channel list, your notification preferences, your alert keywords, your live-alert channels and choices, your Twitch badge alert choice and its records, the Twitch badge ids kept for you, any synced blocked-user IDs, and your synced muted-sender list), on demand. The delete acts on the signed-in account, so if you have signed out, sign back in first. Both delete actions remove only the data Limerino's server holds; nothing on the App Store side is changed. Deleting all server account data also removes a linked Discord account's stored link (see Discord account linking), and on this device it disconnects a linked StreamElements account (see StreamElements account linking) and turns off Mention push alerts, the Twitch badge alert switches and every live-alert switch, All channels included, so this device does not register for alerts, send live-alert channels or send a Twitch badge alert choice again until you turn them back on.

Discord account linking (only if you link one)

If you tap Link Discord on your profile or in Settings → Discord, Limerino's server brokers a one-time Discord authorization. Your Discord access token is used inside that single request, and Limerino asks Discord to revoke it before that request finishes. It is never stored, logged, or kept — that part does not depend on Discord: nothing writes it down either way. If Discord's revoke call itself fails, the token simply expires on Discord's own schedule instead. What is stored against your Limerino account is: your Discord user id, your Discord username, your Discord avatar hash, whether your Discord account has a verified Twitch connection matching this account, and whether you joined the Limerino Discord server. Linking also asks Discord to add you to that server; the disclosure beside the Link Discord button says so before you start, and starting is how you agree.

While a Discord account is linked, Limerino's server also checks every few minutes which roles it holds in the Limerino Discord server, to give your Twitch account any chat badge a role earns (see Limerino chat badges).

Removing it: Unlink on your profile or in Settings → Discord deletes the stored row, and asks Discord to take back the Limerino App role in the server. The row is deleted either way — a Discord outage cannot block an unlink you asked for — so on the rare occasion that call fails, the role can outlive the link until you leave the server or link again. Deleting your Limerino account deletes it too.

Limerino chat badges

Limerino gives chat badges to some Twitch accounts. A badge shows beside the holder's name in chat — in Limerino, and in any other chat app that reads Limerino's badges. Badges are public by design, the way 7TV's are: api.limerino.com publishes the list of badges — each badge's name and images, and a short note on what it stands for and how to get it — and answers anyone who asks which of those badges a given Twitch user-ID shows: every badge that account holds, the one its owner picked to show listed first if they picked one, or none if its owner chose None (exactly as if it held no badge). For an account showing a badge, a single-user lookup also returns every published badge it holds, so other clients can show its collection. It also publishes those answers as one list: the Twitch user-ID of every account that shows a badge, with the badges it shows. Anyone can download that list, and api.limerino.com sends each change to it, as it happens, to anyone who keeps a connection open. Anyone can also look up the Twitch account a user-ID belongs to, so the list says which accounts show a Limerino badge, and a badge's note says how it is earned: by signing up for Limerino within a date range, for example. An account is in that list from the moment it holds a badge until it no longer does, or until its owner chooses None in Badges (see Your own badges below). An account that chose None is not in that list, and no answer carries a Twitch username or anything else about anyone.

To draw badges in chat, the app looks up the people chatting in the channels you have open and, signed in or out, in the chat replayed with a video or clip: it sends the numeric Twitch user-IDs of the authors of the messages and notices it shows there — a direct message mirrored into your channel tabs included, and yours too, when your own messages are among them, when you open Badges, while your linked Discord account is on screen (your profile, or Settings → Discord), or just after you link or unlink a Discord account — to api.limerino.com, in batches of up to 100 and at most one request every two seconds, with no token and nothing else about you, and gets back which Limerino badges each of them shows. The IDs travel in the body of each request, never in its web address. api.limerino.com necessarily receives your device's IP address with these requests, as any server your device contacts does. The app remembers each answer on this device, up to 10,000 at a time, so it does not ask again — for ten minutes when the account shows a badge, thirty when it shows none — and, apart from your own account (on Badges, while your linked Discord account is on screen, and just after you link or unlink a Discord account), never looks up anyone who has not appeared in your chat or in the chat replayed with a video or clip — no chatter lists, follower lists or ranges of IDs.

A badge reaches an account in one of two ways. Given by the Limerino team: the server stores your Twitch user-ID, the Twitch username it matched when the badge was given, an optional note, who gave it, when, and whether it was an exception to the badge's usual rule. Earned by a rule: some badges follow a rule the server checks every few minutes — holding a role in the Limerino Discord server, for example (only while your Discord account is linked; see Discord account linking), or having signed up for Limerino within a date range. For a Discord-role rule the server asks Discord which roles your linked Discord account holds in that server, and stores only whether your Twitch account matches the rule, never the roles themselves. A badge you claim with a button in the Limerino Discord server is recorded as a claim record holding your Discord user id, the badge and when you claimed it; it is kept until the badge is deleted or you delete your server data while that Discord account is linked, and you can ask for it to be removed (see Contact). Each badge the Limerino team gives, takes back or makes an exception for is kept in a change log naming the Twitch user-ID and username involved. When a rule check adds or removes people, the change log records how many, and the Twitch user-IDs of up to 50 of each, without usernames.

Your own badges. Badges, on your profile, lists the Limerino badges you hold and lets you choose which of them shows beside your name: your top badge in catalog order (Automatic, the default; lookups then list every badge you hold), one you pick (lookups list it first, then the rest you hold), or None (lookups leave you out). To fill that screen, the app asks api.limerino.com which badges you hold and since when, what you chose, and what lookups list for you: each time you open Badges or retry there, and again just after you link or unlink a Discord account if you have opened it since the app started. When you choose, it sends your choice and gets the same answer back, and if the server refuses a badge you no longer hold, it asks once more which badges you hold, so the screen stops offering it. The app draws your own badge from that answer and remembers it on this device the way it remembers a lookup answer. Both requests go with your mention-alerts session, which identifies you to the server; your choice is the only other thing they send, and the lookups above never carry that session. The server answers both only about the account the session belongs to. When you got each badge and when you chose are private to that account. Which badge shows beside your name is public: lookups list it first. The public lookups above return only the badges you show and, from the single-user lookup, your published collection. Anyone who keeps copies of the public list, or follows its changes, can still see roughly when an account started showing a badge. Choosing a badge or None stores your Twitch user-ID, the badge you picked or None, and when you chose; choosing Automatic again deletes it. Your choice is not written to the change log above. Other people's Limerino apps pick up a change within about half an hour.

Removing it: deleting your server data (Settings → Mention Vault & data → Your data) deletes every badge given to you, your rule matches, your choice of which badge shows, and the change-log entries naming you. Unlinking Discord takes a Discord-role badge away at the next check. A badge given by the Limerino team stays through the 90-day idle clean-up, and so does your choice of which badge shows while you still hold such a badge, so a None choice keeps it hidden; a badge earned by a rule (a Discord role, a sign-up date) ends when the idle clean-up removes your account, and comes back if you sign in again and still match. Signing in again starts a new account, so a Discord-role badge needs your Discord account linked again, and a sign-up-date badge goes by the new sign-up date. To keep your badges from showing beside your name, choose None in Badges: lookups then leave you out, exactly as if you held none, and so does the public list, though a copy someone downloaded before you chose is beyond Limerino's reach. To have a badge removed otherwise, see Contact.

Twitch badges you can earn, and the ones you have

Earnable now, on Badges and under the Twitch badge alerts in Activity alerts, lists the Twitch badges that can be earned right now and marks the ones you already have; Badges also lists your Twitch badge collection. When you open either screen, pull either to refresh, tap Try again or Check again there, or come back to either after five minutes or more, the app reads your badges and that list from api.limerino.com with your mention-alerts session, which identifies you to the server: the request carries that session, never your Twitch sign-in token, and nothing else about you. They are read only while you are signed in.

To answer, the server reads from Twitch, by your Twitch username and with no sign-in token, the badges Twitch lists for you. Badges you hid on Twitch are left out, so one can show as missing. It reads them at most once an hour, and keeps those badges' ids, never their names or pictures, with the time of the read, to mark what you have and so that badge alerts go only for badges you don't have. It keeps them for a day after the last read; while either Twitch badge alert switch is on, it reads them again about once a day and keeps them (see Twitch badge alerts above). They are deleted once both switches are off and a day has passed since the last read, when you delete your server data, and by the 90-day idle clean-up. The read also keeps three counts under your Twitch username (your global badges, your other badges and the total), deleted once they have not been read for 30 days. The badge names come from Twitch's public list of chat badges, and the badge images come from Twitch (static-cdn.jtvnw.net). Open a live channel asks Twitch, with your Twitch sign-in token, for the live channel with the most viewers in the badge's category, and opens that channel in Limerino.

Earlier versions of Limerino kept a list on this device of the Twitch badges shown beside your name in chat. The app deletes that list when it starts and when you sign out or switch accounts.

The Twitch badge you wear (Twitch)

On the Badges screen, Twitch badge shows which Twitch badge you wear beside your name everywhere, and on Channel badges, Badge in this channel shows the one you wear in that channel; each lists the badges Twitch lets you wear there. When you open one, Limerino asks Twitch for your choice and that list, as badge set IDs and versions only; their names and pictures come from Twitch's public badge lists the app already loads. It asks when the screen opens and when you tap Try again there, never twice within 15 seconds. Nothing is asked in the background or when the Badges screen itself opens.

The request goes to Twitch over the player's Twitch web session (see Twitch authentication), never to a Limerino server, and only when the video player's account check has shown that the web session belongs to the Twitch account you use in Limerino. It carries that channel's Twitch name, or your own for the badge you wear everywhere, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. What Twitch answers is kept in memory only and dropped when you sign out, switch accounts or the web session changes; nothing from it is stored on the device or sent to Limerino. Limerino changes your badge only when you choose one there (below).

Choosing your badge. When you pick a badge on Twitch badge, pick a badge or Use my global badge on Badge in this channel, or tap Wear this badge on a badge you own, Limerino sends Twitch that choice: the badge's set ID and version, and for one channel that channel's Twitch ID. None on Twitch badge, or Stop wearing on the badge you wear, sends Twitch only that you wear no badge everywhere. Wear this badge first checks your badges if the last check is more than 15 seconds old, and sends only a badge Twitch lists for you. Each choice is sent once, only when you tap it, over the player's Twitch web session, never to a Limerino server, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token; Limerino never repeats it by itself. After Twitch takes a choice or does not confirm it, Limerino reads your badge once more, at least 15 seconds after the last read. Until your next message shows the new badge in chat, the Badges screen shows it beside your name from memory; nothing is stored on the device or sent to Limerino.

7TV account linking (only if you link one)

7TV is one of the third-party emote providers Limerino already reads from. You can also link a 7TV account, which lets you change emotes from inside the app: add, remove and rename the emotes in an emote set, and change whether one stacks on the emote before it or wins name clashes; create a new set, rename one, edit its tags, change how many emote slots it has, delete it, or choose which set is active — in your own channel, and in any channel that has made you a 7TV editor. Nothing in this section applies until you link one yourself.

Linking goes through Twitch, not through a 7TV password. Limerino asks 7TV to start a Twitch sign-in, and 7TV answers with the address of an authorization page on Twitch's own domain (id.twitch.tv), which opens in a secure in-app web view. You approve there — Limerino never sees your Twitch password, and it runs no script on that page. Twitch then sends the browser to 7TV's sign-in callback carrying a one-time authorization code; Limerino reads that code out of the address without loading the page, and sends it to 7TV in exchange for a 7TV session token. That web view shares the same Twitch web session as the in-app video player, which is why approving is usually a single tap.

The 7TV session token is stored in this device's Keychain, in its own item, separate from your Twitch credentials. It is never written into your settings, never into a settings export, and never into a log. It is sent to 7TV and nowhere else — not to Limerino's own server, which has no part in this feature.

What the token is used for, and nothing else: reading who your 7TV account is, reading which channels have made you an editor and what those editor rights allow, reading your own account's emote-set limits, reading which name paints and which 7TV badges your own account owns and which of each it currently wears, making the changes you ask for, and — when you disconnect — ending the session it names. A change sends the emote set's id, the emote's id where one is involved, the paint's id when you choose a name paint, the badge's id when you choose a 7TV badge (clearing either sends an explicit empty value, not an id), and whatever you typed or chose — a name, a tag, a number of emote slots, or which set to make active. Creating a set sends no set id, because there is not one yet; creating a set and choosing the active set each also send the 7TV account id of the channel they belong to, and choosing a name paint or a 7TV badge also sends your own 7TV account's id.

Two things about that feature carry no token at all. Reading a channel's public 7TV profile and the contents of its emote sets is a public request, the same kind the app already makes to draw emotes in chat. So is searching the emote directory — though that one does send the words you type into the search box to 7TV, because that is what it searches on.

7TV sessions last 30 days and cannot renew themselves, so the app asks you to reconnect before one ends. Nothing renews it in the background.

Reporting an emote you find in the directory works the way reporting chat does: the action opens that emote's page on 7TV in your browser, where 7TV's own reporting controls are. Limerino sends nothing about it and keeps no copy. You can also hide an emote from your own results, which takes effect immediately and is not sent anywhere.

The lists themselves — the channels and sets you look at, and any emote you have hidden — are held in memory while the app is running and are gone when it is not. Three things outlive that. Your name paints are saved to this device: opening Settings → 7TV account → Name paint writes the list of paints your own account owns — their names, the bundle or event each one came from, which one you are wearing, and your 7TV account's id — into Limerino's own cache here, so the screen opens instantly next time and still works with no signal. Snapshots are kept for up to four recently linked accounts, and only the account you are linked to now is ever shown to you. They are never sent anywhere, and Disconnect 7TV deletes them all — as do signing out and switching Twitch account; the screen reads them from 7TV again the next time you open it. iOS is also free to empty that cache when the device runs low on storage. Emote pictures are saved to this device, the same way every emote the app draws in chat is: browsing the directory or opening a set downloads that artwork into Limerino's own image cache here, where it is reused so the app does not fetch it again. Clear emote cache (Settings → Emote sources) empties that cache; iOS is free to empty it on its own when the device runs low on storage; and deleting the app takes it with everything else. What is kept is the picture — the words you type into the search box are not written down with it. The other is a name you are part-way through typing, kept in that screen's own restoration state — along with which emote, in which set, of which channel it belongs to — so the sheet survives a backgrounding; it goes when iOS discards the window. Keeping either one uploads nothing, and a name you typed reaches 7TV only when you save it.

To remove: Disconnect 7TV on the 7TV account row asks 7TV to end the session, then deletes the stored token from this device's Keychain — and tells you if the deletion did not land. A 7TV link belongs to the one Twitch account that made it: signing out of Limerino, or switching to a different Twitch account, keeps its token on this device for that account, unused until you sign back in, and no other account can use it. Removing that Twitch account from this device ends the 7TV session and deletes the token, as Disconnect 7TV does. Disconnecting undoes none of the emote changes you already made, and Limerino cannot delete data that 7TV holds — use 7TV's own controls for that.

StreamElements account linking (only if you link one)

StreamElements runs a chatbot that many Twitch channels use for commands, timers and chat moderation. You can link a StreamElements account to see and change that bot's settings from inside the app: whether it is in chat or muted; its timers; its custom commands and the settings of its built-in ones; its spam filters and banned phrases; its modules; the viewers it treats as Regulars or Super Moderators; its counters; and its quotes — in your own channel, and in any channel where StreamElements gives you a Bot Supervisor, Editor or Full Control role. Nothing in this section applies until you link one yourself.

Linking happens on StreamElements' own pages. On the StreamElements screen (Profile → Connections → StreamElements), the app first tells you what linking lets Limerino do. When you then tap Connect StreamElements, Limerino's server answers with the address of StreamElements' authorization page, which opens in a system browser sheet that shares Safari's StreamElements session. You sign in and approve there — Limerino never sees your StreamElements password. StreamElements then sends the browser back to Limerino's server (api.limerino.com) with a one-time authorization code, which the server passes straight back to the app without storing it (the hosting provider's request log records that return address, code included; the code works once and is useless without a secret only the server holds), and the app sends the code to the server to finish the link. That step runs on Limerino's server because StreamElements requires a secret that only that server holds.

To finish the link, Limerino's server exchanges the code with StreamElements for your StreamElements tokens and reads who the account is: its StreamElements id, name and display name, the Twitch account it belongs to, and the permissions you approved. It checks that the Twitch account is the one you are signed in with and that you approved what the feature needs, then hands the tokens and those details to the app in its answer. It stores none of them: no StreamElements token and no detail of your StreamElements account is written to its database, its logs never carry a token, the code or your StreamElements name, and they record the account's id only in a scrambled, one-way form. If a check fails, or the answer cannot reach the app, the server asks StreamElements to revoke the new tokens before it answers, and the app tells you why the link did not go through. While a link is in progress, the server keeps one short record of it — a random code, your Twitch user-ID, the permissions asked for, and a one-time secret that proves StreamElements' reply belongs to that start — deleted when the link finishes, and otherwise at the next daily clean-up.

The StreamElements tokens are stored in this device's Keychain, in their own item, separate from your Twitch credentials, with the account's StreamElements id, name and display name, the Twitch account it belongs to, the permissions you approved and when the tokens expire. They are never written into your settings, never into a settings export, and never into a log. They are sent to StreamElements, and to Limerino's server only when they are renewed, which keeps no copy.

What the tokens, and the manager sessions they obtain, are used for, and nothing else: reading the channels where StreamElements gives you a role, and what that role is; reading each of those channels' public StreamElements profile, to match it to its Twitch channel; reading whether your own bot is in your chat and, while it is not, whether it has any commands or timers; asking StreamElements for a manager session when you open the bot controls of a channel you help manage; reading the bot settings of the channel you open; making the changes you ask for; checking that a token still works before the app treats a link as ended; and revoking the tokens that are being replaced or disconnected. A change sends the id StreamElements gave the item you change or delete, and whatever you typed or chose: a command's name, reply, aliases, cooldowns, cost and who may use it; a timer's name, messages, intervals and chat-line count; a filter's settings, its allowed and blocked links and banned phrases; a module's settings and messages; a counter's value; a quote's text; or muting, unmuting or inviting the bot. Adding a viewer to Regulars or Super Moderators also sends that viewer's Twitch user-ID, which Limerino looks up from their Twitch name the way it looks up any Twitch user. Before an edit to a timer, a command, a filter, a module or a banned-phrase group is saved, the app reads that item fresh from StreamElements and sends it back with only your change in it, so settings the app does not show stay as they were.

A manager session is StreamElements' answer for a channel you help manage: StreamElements decides what it may do from your current role there. Limerino keeps a manager session in memory only, for at most an hour, and never writes it down; it is dropped sooner when you disconnect, sign out or switch account, when StreamElements no longer lists your role there, or when StreamElements turns it down.

StreamElements tokens last 30 days. While you use the feature, the app renews them through Limerino's server when fewer than seven days are left, or when StreamElements turns the current one down, sending the server your current refresh token; the server checks again that the account belongs to your Twitch account and hands back new tokens without keeping any. The app then asks StreamElements to revoke the tokens it replaced. Nothing renews them while the app is closed.

What the app reads from StreamElements — your roles, the channels they are in, and the bot settings you look at — is held in memory while the app is running and is gone when it is not. The Regulars and Super Moderators list StreamElements sends carries each viewer's last chat message; Limerino drops it as it arrives and never shows or keeps it. Command replies and module messages are shown as plain text, and links in them cannot be tapped.

Show bot controls in chat (on the StreamElements screen and in Settings; on unless you turn it off) shows the bot-controls button at the top of chat. While it is on and an account is linked, the first time chat opens after the app starts or you sign in, the app reads your roles and your own bot's status from StreamElements to decide where the button belongs. With it off, the button is gone and opening chat sends nothing to StreamElements.

To remove: Disconnect StreamElements on the StreamElements screen drops every manager session, asks StreamElements to revoke the tokens, then deletes them from this device's Keychain — and tells you if the deletion did not land. It works even while the feature is switched off. A StreamElements link belongs to the one Twitch account that made it: signing out of Limerino, or switching to a different Twitch account, keeps its tokens on this device for that account, unused until you sign back in, and no other account can use them; manager sessions are dropped at once. Removing that Twitch account from this device revokes the tokens and deletes them, as Disconnect does, and so does deleting all server account data from Settings → Mention Vault & data → Your data. Each device you link on has its own link, so disconnecting on one leaves the others linked; to take away Limerino's access everywhere at once, remove Limerino from the apps connected to your account in StreamElements' own account settings. Disconnecting undoes none of the bot changes you already made, and Limerino cannot delete data that StreamElements holds — use StreamElements' own controls for that.

Diagnostics (Settings → Data & advanced)

Settings → Data & advanced → Diagnostics can generate a read-only status report to help debug a problem: whether you are signed in, which Twitch scopes you granted, your Twitch user-ID, the active channel, and the embedded player's session state. It contains no tokens, passwords, or other secret values — only on/off flags and identifiers. The report is shown on screen and you can copy it; nothing is uploaded automatically. It only leaves the device if you choose to copy and send it, or if you attach it to a feedback submission via Settings → Report a Bug or Suggest a Feature (see Bug reports & feature suggestions below).

Bug reports & feature suggestions (Settings → Support)

Settings → Report a Bug and Suggest a Feature send your typed text to the developer through the same optional, user-initiated upload: nothing is sent unless you type something and tap Submit. When you do, Limerino sends to its backend (api.limerino.com, hosted on Railway):

the description you typed;
basic device metadata — the app version and build number, your iOS version, your device model (e.g. iPhone16,2), and your system language — which is always included so a report can be reproduced, even when you turn Include diagnostics off. It carries no Twitch identity on its own; and
unless you turn off the Include diagnostics toggle (on by default for a bug report, off by default for a feature suggestion), the same read-only diagnostics report described above — which, when you are signed in, includes your Twitch username, display name, and user-ID, the Twitch scopes you granted, the active channel, and the player's session state. It never includes your messages, tokens, or passwords.

While Include diagnostics is on, View what's sent shows — before you submit — the exact diagnostics text that will travel with the submission. This upload is not tied to mention alerts and needs no sign-in — anyone can send one. A bug report is used only to reproduce and fix the problem, and a feature suggestion only to consider the idea. Leaving Include diagnostics off removes your Twitch identity from the submission, but the basic device metadata above still travels with it.

Tapping Submit stores the typed description, basic device metadata, and any diagnostics you chose to include in Limerino's private backend database, along with its processing status, the resulting structured triage decision, and request usage/cost metadata. When a request is kept for follow-up, its typed description, basic device metadata, and any diagnostics you chose to include — including the Twitch identity shown in the diagnostics preview — are also copied into an issue or comment in the developer's private GitHub issue tracker. Obvious spam can be rejected without being copied to GitHub.

Submissions are triaged automatically: Anthropic processes the typed description and basic device metadata to classify the submission and check for likely duplicates before it is filed. Diagnostics are never shared for automated triage — they are never sent to Anthropic and stay in Limerino's private backend. Anthropic processes everything Limerino sends it for triage under its commercial API terms and data processing addendum, which require it to protect this data with at least reasonable care. Anthropic does not use this data to train its models, and deletes it within 30 days unless it needs it longer to enforce its usage policy or to comply with the law.

The backend necessarily receives the connection's IP address. It immediately combines that address with a private random salt and stores only the resulting one-way hash for abuse prevention and rate limiting; the raw IP address is not stored. During triage, that salted hash is also sent to Anthropic as a privacy-preserving safety identifier.

Where your report is posted, and crediting it to you (optional). Every report or suggestion that is kept for follow-up is also posted as a thread in the public Limerino Discord community, so other users can see it, follow it, and vote on suggestions. That post carries the text you typed and the basic device metadata — never your diagnostics — and it carries your username whenever crediting is on; see below for when that is the default.

In current versions of Limerino, when you file while signed in, the post is credited to you by default: the compose sheet's Include my username switch starts on, and the post is credited to your Twitch display name, with a link to your Twitch channel — or, if you have linked a Discord account (see Discord account linking), to that Discord account instead, with your Discord profile picture if you have one, and a link to your Discord profile, and the Limerino bot can send you a Discord message linking the post so you can follow replies (Discord only delivers those over a shared server, so you may not get one). Turn the toggle off before sending, or file while signed out, and none of that is shared: the submission is identical to one sent before this option existed, and the section does not appear at all when you are signed out. Where that switch starts off, or a version never offered it at all, the post carries no username unless you turned it on.

Choosing to be credited stores one extra thing against your report: a reference to your Limerino account. Crediting keeps no copy of your username — the username shown on the post is looked up at the moment it is posted, so unlinking your Discord account beforehand means the post credits your Twitch account instead. Deleting your account (see Deleting your account) removes that reference; it does not retract a post that has already been made. Crediting adds nothing to the developer's GitHub issue tracker — neither the account reference nor the username shown on the Discord post is copied there. (Diagnostics you chose to attach are copied there, and those do include your Twitch identity — see above.)

To remove: bug reports and feature suggestions are developer-side issues, not stored on your device. The backend copy is deleted automatically 180 days after you send it (see Retention); to have one removed sooner, to ask about the copy in the developer's issue tracker, or to ask for a Discord post to be taken down, email hello@meipath.com.

Recent-messages backfill (`recent-messages.robotty.de`)

When you are signed in and open a channel, Limerino can fetch a short window of recent chat from before you joined, so you have scrollback. This comes from the third-party community service recent-messages.robotty.de. Only the channel name is sent — nothing about you, and no token.

To disable: Settings → toggle off Fetch recent messages on join.

A channel's public chat details (Twitch)

While you are signed in and a channel's chat is on screen, Limerino asks Twitch for some of that channel's public chat details, the ones Twitch shows every viewer on its own site. The pinned message, if you don't moderate the channel (in a channel you moderate, Limerino reads the pin through Twitch's API with your sign-in token instead): when you open or switch to the channel, come back to the app, reconnect or type /pin, and once when a timed pin ends, never more than once every 15 seconds for that channel, unless you turn off Show pinned message in Settings, which stops both reads. Whether a poll or a Hype Train is running, and how it is going. While a channel's chat is on screen, Limerino checks for a poll about every minute and, once you turn on Hype Train in Settings, for a Hype Train about every two minutes, and updates one that is running about every 15 seconds. It also checks the poll when you pull to refresh it or tap Try again. Hype Train is off until you turn it on, and Limerino never checks for a Hype Train while it is off. Turn off Polls in Settings and Limerino stops checking for polls. The names and costs of the channel's Channel Points rewards, so a redemption in chat can say which reward it was: once, when the first redemption shows in chat, and not again until the app restarts or you sign in again, unless you turn off Show reward names or Channel Points in Settings. The channel's chat rules, when you open the rules sheet, from Read on the rules card before your first message or from Chat rules on a warning, timeout or ban, or tap Try again there (if they fail to load, it also tries again by itself up to three times, a minute apart, while Chat rules is open), and once the first time you tap the message box in a channel where you have never chatted, to see whether it has rules to offer you, unless you turn off Chat rules in Settings.

Each of these requests carries the channel's Twitch name or ID (the Hype Train check carries the IDs of the channels on screen, at most 10). Limerino sets four headers on it and no others: two naming the format of the request and of its answer, Twitch's public web client ID (the one Twitch's own website uses), and the app's name and version with your iOS version. iOS then adds the standard headers it puts on every web request: the host name, the length of the request, the connection, the compression it accepts, an instruction not to use a cached copy, and your preferred languages. It carries no token, no cookie, no device ID and no session ID, and Limerino adds nothing about you; Twitch sees your device's network address, as it does for any request. Nothing is asked for a channel that is not on screen (apart from the one check of its poll after you start or end one there as a moderator), while the app is in the background, or while you are signed out. In your own channel, only its poll and chat rules are asked for. What Twitch answers is kept in memory only and dropped when you sign out or switch accounts; nothing from these requests is stored on the device or sent to Limerino.

Voting in a poll (Twitch)

In any channel, your own included, you can vote in a running poll from its sheet: pick a choice, then tap Vote. While the sheet is open, Limerino asks Twitch whether you have already voted in that poll and for which choice: when the sheet opens, unless Twitch answered about that poll in the last 15 seconds, and once after each vote, never twice within 5 seconds. Apart from that one check after a vote, nothing is asked in the background or while the sheet is closed.

Extra votes for Channel Points. On a poll that lets you add votes with Channel Points, once you have voted for one choice the sheet shows what an extra vote costs, in the channel's points, before you can tap Add a vote. Each tap sends one extra vote for that choice, spending that cost, once: Limerino never adds a vote by itself and never repeats one by itself, and an extra vote Twitch did not confirm is sent again, with the same vote ID, only if you tap Try again. While the sheet is open, the check of whether you voted also asks for your Channel Points balance in that channel and how many votes you have, so the sheet can show them.

Your vote carries the poll's and the choice's IDs, your Twitch user-ID and a random vote ID the app makes for it; the check carries the channel's Twitch name. Both go to Twitch over the player's Twitch web session (see Twitch authentication), never to a Limerino server, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token, and only when the video player's account check has shown that the web session belongs to the Twitch account you use in Limerino. A vote is sent once, only when you tap it: Limerino never votes by itself and never repeats a vote by itself, and a vote Twitch did not confirm is sent again, with the same vote ID, only if you tap Try again. What Twitch answers is kept in memory only and dropped when you sign out or switch accounts; nothing from it is stored on the device or sent to Limerino.

Polls you run as a moderator (Twitch)

In a channel you moderate that isn't yours, the poll sheet offers Start a poll when no poll is running, and End poll while one runs. Starting sends Twitch the channel's Twitch ID, your question, the choices, how long the poll runs and whether viewers can add votes with Channel Points, with their cost; ending sends the poll's ID, after you confirm. Each goes to Twitch once, only when you tap it: Limerino never starts or ends a poll by itself and never repeats a request by itself, and one Twitch did not confirm is sent again only if you tap Try again, after Limerino has checked the channel's poll once. These requests go to Twitch over the player's Twitch web session (see Twitch authentication), never to a Limerino server, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. A poll you are still writing is kept in memory only, until Twitch starts it, you sign out or switch accounts, or the app quits; nothing from this feature is stored on the device or sent to Limerino. In your own channel, polls use Twitch's API with your Twitch sign-in token (the api.twitch.tv row under How the data leaves the device).

Your standing and chat access in a channel (Twitch)

While you are signed in and a channel's chat is on screen, Limerino asks Twitch two things about you in that channel, so it can tell you why chat would refuse you there, before you type or right after.

Whether you can chat there. Limerino asks Twitch for the reasons, if any, it would refuse your messages in that channel (for example followers-only, subscribers-only, or a phone number or email it needs you to verify): when you open a channel that is in followers-only or subscribers-only mode, when you first tap its message box, and after Twitch refuses a message you sent there because of a chat mode or something about your account; never more than once a minute for that channel, and never in your own channel or one where you are a moderator or VIP. Limerino shows the reason above the message box and never stops you from sending. The same answer says whether you have chatted in that channel before; Limerino uses it only to offer the channel's rules before your first message there.

Your standing. Limerino asks Twitch whether a moderator has warned you, timed you out or banned you in that channel, with the reason they gave and any chat rules they cited, never who did it: the first time you open the channel after the app starts, you sign in or the web session changes; after Twitch refuses a message there because of a warning, timeout or ban or says in chat that you were timed out or banned (for a channel that is not on screen, once it is); and, while it knows of a warning, timeout or ban for you there, each time you come back to that channel and once after Twitch accepts a message you send there, and for a timeout or ban also when you tap its message box; never more than once every 30 seconds for that channel, and never for your own channel. Limerino shows it in a row at the top of that channel's chat. Turning off Show when you're warned or timed out in Settings hides that row, and Limerino still asks, so the message box can say why chat refuses you.

These two requests go to Twitch over the player's Twitch web session (see Twitch authentication), never to a Limerino server, and only when the video player's account check has shown that the web session belongs to the Twitch account you use in Limerino. Each carries the channel's Twitch name, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. What Twitch answers is kept in memory only and dropped when you sign out, switch accounts or the web session changes; nothing from these requests is stored on the device or sent to Limerino.

Acknowledging a warning. When a moderator has warned you in a channel, tapping Acknowledge on the warning sends Twitch your acknowledgement, so you can chat there again. It carries the channel's Twitch ID, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token, over the player's Twitch web session, never to a Limerino server. It is sent once, only when you tap it: Limerino never acknowledges a warning by itself and never repeats it by itself. If Twitch doesn't confirm it, Limerino reads your standing there once more, at least 30 seconds after the last read, to see whether the warning is gone. Nothing from it is stored on the device or sent to Limerino.

Follow & subscription details on a user card (Twitch and `api.ivr.fi`)

When you tap a chatter's name, the card can show how long they have followed the channel you are watching and their public subscription standing there. The two answers come from two places.

How long they have followed comes from Twitch's own API, using your signed-in session — but only where Twitch lets you ask: about yourself, or about another chatter in a channel you moderate. For anyone else Limerino asks nobody and shows nothing, rather than guessing.

Their subscription standing comes from api.ivr.fi, a third-party community service Limerino does not operate. One request goes out when the card opens, carrying two public Twitch names — that chatter's and the channel's. No token and no account — though if the chatter whose card you open is yourself, that name is by definition your own public Twitch name. What comes back is kept in memory for the session and is never stored or forwarded. If the request fails, or the service says it does not know that chatter, the card simply shows no such details.

If a chatter has hidden their subscription status on Twitch, Limerino does not show it — only the public follow date.

Pronouns (`api.pronouns.alejo.io`)

Pronouns are off unless you turn them on in Settings → Names & text. They come from alejo.io's pronoun service, where people set their own pronouns, a third-party community service Limerino does not operate.

While Show pronouns on user cards is on, opening a chatter's card sends that chatter's public Twitch username to api.pronouns.alejo.io. While Show pronouns in chat is on, the same lookup goes out for the people whose messages Limerino shows you in chat, at most once an hour for each person (two minutes after a lookup that failed). The first lookup each time the app runs also fetches the service's public list of pronoun sets. No token and no account are sent, though if the person is you, that username is by definition your own. The service can see your device's IP address, as any site your device contacts can.

What comes back is the pronouns that person chose, or that they have none. Limerino keeps it in memory only while the app runs, asks again after an hour, and never stores or forwards it. It shows pronouns only when the service's record matches that person's Twitch account, and never guesses: a person with no record shows none.

To disable: Settings → Names & text → turn off Show pronouns on user cards and Show pronouns in chat. With both off, the service is never contacted.

Moderator history on a user card (Twitch)

If you moderate a channel, the card of a chatter there has a Moderation history row, unless you turn off Moderation history in Settings. When you open it, Limerino asks Twitch whether it shares the channel's moderator history with you, and then for that person's history in that channel: whether they are banned or timed out right now, with the reason and the moderator who did it (never in your own channel); their past bans, timeouts, warnings and unbans, each with its kind and time; their messages there, deleted ones and ones AutoMod held included; and the comments the channel's moderators left about them. That is at most five requests when the page opens. Show older asks for 20 more messages or comments, at most 10 pages of messages and 5 of comments each time you open the page, and Show comments from other channels asks for the comments other channels shared about that person, one page per tap, at most 5. The same request is never sent twice within 10 seconds, and nothing is asked in the background or for a card you are not looking at, apart from the one check after a comment change described below.

These requests go to Twitch over the player's Twitch web session (see Twitch authentication), never to a Limerino server, and only when the video player's account check has shown that the web session belongs to the Twitch account you use in Limerino. They carry the channel's Twitch ID and that person's Twitch user-ID (and, for Show older, Twitch's marker for where the last page ended), with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. If Twitch doesn't share the history with you, the page says so. The row is never on your own card or the broadcaster's, and it is not offered when you turned off the ban and timeout permission or the moderator log under Choose permissions. This is other people's data: it is kept in memory only while the page is open and dropped when you leave it or stop moderating the channel; nothing from these requests is stored on the device or sent to Limerino.

Adding and deleting a comment. At the top of Moderator comments you can write a comment about that person for the channel's moderators, up to 500 characters, and tap Add; on a comment you wrote, you can tap delete and confirm. Each goes to Twitch once, only when you tap it: Limerino never repeats it by itself, and never asks Twitch to share your comment with other channels. A comment carries the channel's Twitch ID, that person's Twitch user-ID and your text; a deletion carries the comment's ID and the channel's Twitch ID. They go over the player's Twitch web session, never to a Limerino server, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. If Twitch doesn't confirm one, Limerino reads the first page of comments once more, at least 10 seconds after the last read, and then offers Try again. The channel's moderators can see your comment on Twitch. A comment you are still writing is kept in memory only, until you send it, stop moderating the channel, sign out, switch accounts or the web session changes, or the app quits; it is never stored on the device or sent to Limerino.

Follow, unfollow and the watch bonus (Twitch)

When you tap Follow on someone's user card, confirm an unfollow there, or type /follow or /unfollow, Limerino asks Twitch to follow or unfollow that person, at most once per tap or typed line. When Twitch offers you a watch bonus in a channel, the Channel Points sheet shows Claim bonus, and a claim is sent only when you tap it. Limerino never follows, unfollows or claims a bonus by itself, and never repeats one of these requests by itself. Whether you already follow someone comes from your list of followed channels, or from one request to Twitch's API (the api.twitch.tv row under How the data leaves the device); after Twitch answers a follow or an unfollow, Limerino checks it there with up to three more of those requests and refreshes that list.

Twitch accepts these three requests only with its integrity token, which comes from a check Twitch's own website runs in the browser. So for each one, and for nothing else, Limerino opens Twitch's own page for that person or channel, www.twitch.tv/popout/<name>/viewercard/<name>, in a secure web view beneath Limerino's own screen, where you don't see it and can't touch it. Twitch's page and its check run unchanged. Limerino then runs one function of its own in that page, which asks Twitch for the integrity token and sends your request with it, the way Twitch's website does. The token stays inside that page: Limerino never reads it out, logs it or stores it. The page closes as soon as Twitch answers, after at most 30 seconds, or when you sign out, switch accounts or the web session changes.

These requests go to Twitch over the player's Twitch web session (see Twitch authentication), never to a Limerino server. Each carries what you asked for: the person's Twitch ID for a follow or unfollow, and for a claim the channel's ID and the bonus's ID. With each one, and with the request for the token, go the web session, the device identifier Twitch itself set in it, a session identifier made for that page and the web view's standard browser identification. While the page is open, it talks to Twitch's servers the way twitch.tv does in a browser, including the requests Twitch's own pages make to its partners (such as an Amazon ad-system identity sync); Limerino adds none of them. Twitch answers whether the follow, unfollow or claim went through and, for a claim, your new balance.

Limerino acts only when the video player's account check has shown that the web session belongs to the Twitch account you use in Limerino, as for Channel Points. When the web session is missing, unconfirmed, expired or someone else's, Limerino offers Sign in again; when Twitch refuses, or its page doesn't answer in time, Limerino says so in one line. Limerino never sends you to Twitch to finish an action. With Follow and unfollow off in Settings, the Follow button is hidden and no follow or unfollow is sent; with Claim watch bonuses or Channel Points off, no claim is shown or sent; with Web features off, or while Limerino has turned these off from its own server, none of the three is sent. Twitch's answers are kept in memory only and never sent to Limerino.

Channel Points (Twitch)

When you open Channel Points from the top of chat, Limerino asks Twitch for your points balance and the channel's rewards: when the sheet opens, about once a minute while it stays open on screen, and at most once after a redemption or a watch-bonus claim. A redemption is sent only when you tap it, and so is a claim of the watch bonus Twitch offers you there (see Follow, unfollow and the watch bonus). With Channel Points off in Settings, none of this shows and nothing is sent. Limerino never claims a bonus by itself and never repeats a request by itself: each claim and each redemption is sent once per tap, and a redemption Twitch did not confirm is sent again, with the same transaction ID, only if you tap Try again.

Your balance at the top of chat. In another channel's chat, your points balance shows at the top. It comes from the predictions check described under Predictions, which already asks for it, and from the sheet's own requests when you open it. When Limerino can't check that channel's predictions (with Predictions off in Settings, for example), it asks Twitch for your balance and the channel's rewards, the same request the sheet makes, when the chat opens unless your balance there was read in the last two minutes, and about every two minutes while the chat stays on screen. It never asks for your own channel, a channel that isn't on screen, while the app is in the background or while you are signed out, and not at all while Channel Points or Web features is off, or while Limerino has turned this check off from its own server. It also stops asking for a channel once Twitch has answered that its Channel Points are off.

These requests go to Twitch over the player's Twitch web session (see Twitch authentication), never to a Limerino server. Each carries what you asked for: the channel's Twitch name or ID, and, for a redemption, the reward's ID, cost, title and prompt, any message you typed for it, and a random transaction ID the app makes for that redemption. With each one go the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session. None of them carries an integrity token. Twitch answers with your balance, the channel's rewards, and whether the redemption went through. A watch-bonus claim is the one that does (see Follow, unfollow and the watch bonus).

Twitch's emote unlocks (Unlock a Random Sub Emote, Choose an Emote to Unlock and Modify a Single Emote) work the same way. When you open one, Limerino asks Twitch which of the channel's subscriber emotes it can unlock and their effects, in a request like those under A channel's public chat details: the channel's Twitch name, with no token, cookie, device ID or session ID. It asks when the screen opens, when you tap Try again, and once after Twitch says an emote can't be unlocked, never twice within 10 seconds, and it keeps the list for 10 minutes. An unlock is sent only when you tap Unlock, once per tap, over the player's Twitch web session: the channel's ID, the reward's cost, a random transaction ID the app makes for that unlock and, for an emote you chose, that emote's ID. An unlock Twitch did not confirm is sent again, with the same transaction ID, only if you tap Try again. When Twitch confirms one, that emote joins your emotes for that channel for 24 hours, kept in memory only and dropped when you sign out or switch accounts.

Limerino acts only when the video player's account check has shown that the web session belongs to the Twitch account you use in Limerino. That check runs again before a request when your sign-in or the web session has changed since the last check, and again if Twitch answers as a different account (the id.twitch.tv row under How the data leaves the device). When the web session is missing, unconfirmed, expired or someone else's, Limerino says so and offers Sign in again; when Twitch refuses a request, Limerino says so. Limerino never sends you to Twitch to finish an action.

Reward pictures and the channel's points icon load from Twitch's image server (static-cdn.jtvnw.net) with no token and nothing about you. Your balance and the rewards are kept in memory only, and dropped when you sign out or switch accounts; nothing from this feature is stored on the device or sent to Limerino.

When you open Channel Points in a channel you subscribe to, after your points have loaded, Limerino asks Twitch whether you have a resub to share there: once each time the sheet opens, reusing an answer for a minute, never twice within 10 seconds, and once more when you open the share screen on an answer more than a minute old. Apart from the one check after a share described below, nothing is asked for your own channel, while the sheet is closed, or in the background.

When you tap Share in chat, Limerino sends Twitch the channel's Twitch name, Twitch's ID for your resub, whether to include your streak and the message you typed, if any; Twitch then posts your resub in that channel's chat, where everyone there sees it. A share is sent once, only when you tap it: Limerino never shares by itself and never repeats a share by itself, and a share Twitch did not confirm is sent again only if you tap Try again, after Limerino has checked once, at least 10 seconds after the last check, whether the resub is still there to share. These requests go to Twitch over the player's Twitch web session (see Twitch authentication), never to a Limerino server, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. What Twitch answers, and a message you have not sent yet, are kept in memory only until you sign out, switch accounts or the web session changes, or the app quits; nothing from this feature is stored on the device or sent to Limerino.

Predictions (Twitch)

In your own channel, the Predictions panel uses Twitch's API with your Twitch sign-in token (the api.twitch.tv and eventsub.wss.twitch.tv rows under How the data leaves the device).

In any other channel, while its chat or its Predictions screen is on screen, Limerino asks Twitch for that channel's running and recent predictions: each question and its outcomes, how many people and points are on each outcome, the top predictors' names as Twitch shows them to every viewer, and your own prediction and Channel Points balance there. It asks when that channel's chat or Predictions screen opens, every 15 seconds while a prediction there is taking points, every 30 seconds while one is waiting for its result, every minute otherwise, once after anything you send, and when you pull to refresh or tap Try again. It never asks for a channel that isn't on screen, or while Limerino is in the background. With Predictions off in Settings it asks and sends nothing about predictions in a channel that isn't yours; your own channel's panel stays. The read that confirms a prediction you just placed, or a change you made as a moderator, waits until that channel is on screen again with the app open.

When you confirm a prediction, Limerino sends Twitch the prediction's and the outcome's IDs, the points you chose and a random transaction ID the app makes for that prediction. If you moderate the channel, starting a prediction sends its question, its outcomes and how long it takes predictions, and locking it, choosing its winner or cancelling it sends the prediction's ID and, for a winner, that outcome's ID. Each is sent once, only when you tap it: Limerino never predicts, starts or ends a prediction by itself and never repeats a request by itself, and a prediction Twitch did not confirm is sent again, with the same transaction ID, only if you tap Try again. If Twitch asks you to accept its prediction terms first, Limerino says so: Read the terms opens Twitch's terms in the in-app browser, and only when you tap Accept terms does Limerino send Twitch your acceptance, once. You then place your prediction yourself. Limerino never accepts the terms by itself or for anyone else.

These requests go to Twitch over the player's Twitch web session (see Twitch authentication), never to a Limerino server, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session. None of them carries an integrity token. Limerino acts only when the video player's account check has shown that the web session belongs to the Twitch account you use in Limerino; when it cannot act, it says so, and offers Sign in again when the web session is the reason, as it does for Channel Points.

What Twitch sends back is kept in memory only, and dropped when you sign out or switch accounts; top predictors you have blocked are not shown. Nothing from this feature is stored on the device or sent to Limerino.

Clips and past broadcasts (Twitch)

Creating a clip. While a channel you are watching is live, choosing Create clip in its chat, or typing /clip, asks Twitch's API, with your Twitch sign-in token, to make a clip of that stream. The request carries the channel's Twitch ID and, if you gave one, a title. Twitch makes the clip and shows it publicly on that channel, as it does for a clip made on Twitch. Limerino then asks Twitch's API for the new clip up to five times over the next 15 seconds, to show it once it is ready. A clip is made only when you ask for one. With Create clips off in Settings, none of this shows and nothing is sent.

Your clips. Limerino keeps a list of the clips you create in Limerino, on this device only, so Your clips can show them: each clip's ID, its channel's Twitch ID and name, when you made it, and whether Twitch has finished it, up to the newest 500. The list belongs to the account you made them with, and no other account sees it; it stays when you sign out, and it is never uploaded. When you open Your clips, Limerino asks Twitch's API, with your sign-in token, for those clips' details, 100 at a time: the first ones when the list opens, more as you scroll, and again when you pull to refresh. Removing a clip from the list removes it only from this device; the clip stays on Twitch. Turning Create clips off hides Your clips and sends nothing, and the list stays on this device. When you remove the account from this device, its list is deleted the next time the app starts.

Clips and past broadcasts in Limerino's player. While you are signed in and Player type is Native, clips, and past broadcasts when Limerino's player can play them, play in Limerino's own player. It asks Twitch for permission to play that video over the player's Twitch web session (see Twitch authentication), with the same identification as live video and no integrity token, then loads the video from Twitch's video servers. It sends no playback report of its own and no watch-time report. When Limerino's player can't get a video, Twitch's own player plays it, as it always has, unless Twitch says the video is only for subscribers, isn't available in your region or no longer exists: then Limerino says so. Choosing Embedded under Settings → Video → Player type plays every clip and past broadcast in Twitch's player. What Twitch answers is kept in memory only; nothing from these requests is stored on the device or sent to Limerino.

Link previews (`i.imgur.com`, `pbs.twimg.com`, `cdn.discordapp.com`, `clips-media-assets2.twitch.tv`, `kappa.lol`, `segs.lol`)

When chat contains a link whose URL is on Limerino's small CDN whitelist (typed in Limerino/Features/Chat/Rendering/LinkPreview.swift), the app fetches a thumbnail directly from that CDN over HTTPS to render an inline preview. The hosts named above are the whole list. No referrer is sent; the redirect chain is hard-disabled.

kappa.lol and segs.lol — the image hosts Limerino offers for Image uploads — are handled differently, and more cautiously. Their pictures are off unless you ask for them. Settings → Links & images → Pictures from image hosts is off unless you turn it on, and while it is off a link to one of those hosts is just a link: no picture, no card, and your device does not contact that host at all for something someone else posted. The same setting governs the host you configure in Image uploads, which joins that list only while both Image uploads and Pictures from image hosts are on. Turning either one off removes it. Turning Pictures from image hosts on applies to links other people post, not only to images you uploaded yourself — Limerino cannot tell whose picture an address points at without asking the host, which is the request the setting exists to withhold.

To disable: Settings → Links & images → toggle off Inline link previews for every host in this section, or leave Pictures from image hosts off for the two above and your own configured host.

GIFs sent in chat (`media*.giphy.com`)

Twitch has a built-in GIF feature. Subscribers of some channels can send a GIF, and Twitch delivers it to everyone watching as a short description in the message plus the address of the picture, which is hosted by GIPHY. Settings → Emote & badge display → Show GIFs sent in chat is on unless you turn it off.

While it is on, your device asks GIPHY for that picture when the GIF scrolls into view. The request carries the address exactly as Twitch supplied it, including the analytics parameters GIPHY puts in its own links, and nothing about you: no account, no token, no name, and nothing you typed. Twitch's rules for this feature require apps to use that address unchanged, so Limerino cannot trim those parameters. GIPHY can see your device's IP address, as any site you load a picture from can.

Turning Show GIFs sent in chat off means a GIF arrives as the short description Twitch sends with it, shown as ordinary text. Your device contacts GIPHY for nothing at all.

The picture is kept in Limerino's own image cache on your device, so scrolling back to the same GIF does not fetch it again. Clear emote cache (Settings → Emote sources) empties that cache along with the emote artwork it already covers, and iOS is free to empty it on its own when the device runs low on space.

That default is the opposite of Pictures from image hosts above, on purpose. A GIF here is part of a Twitch chat message: Twitch delivers it over the same connection as the message itself, from the partner it contracted for the feature, and it is what every other Twitch chat surface shows by default. A picture from an image host is a link to somewhere else that a stranger chose to post, so that one stays off until you ask for it.

To disable: Settings → Emote & badge display → toggle off Show GIFs sent in chat.

Image uploads (`kappa.lol`, or the host you configure)

Available by default, and it uploads nothing on its own. Settings → Links & images → Image uploads → Upload images is on unless you turn it off. Being on only means the app will accept an image: nothing is sent unless you attach or paste one yourself in the message box. There is no background upload, no scan of your photos, and no upload of anything you did not pick.

When you do attach or paste an image in chat, Limerino uploads that image to the host named on that screen — kappa.lol unless you change it — and puts the link the host returns into your message box. Limerino does not send the message for you; you decide whether to post the link, and you can delete it from the box instead.

Turning Upload images off removes the whole affordance — no photo option on the message box, and a pasted image is refused rather than uploaded — and this section stops applying to you.

Before anything is sent, Limerino removes the image's location and camera information on this device — GPS coordinates, capture time, and camera or phone model. There is no setting for this; it always happens.

Picking a photo uses Apple's system photo picker, which runs outside Limerino. The app receives only the image you picked and is never given access to your photo library, which is why iOS does not ask you for photo permission.
No account, no token, and nothing about your Twitch identity is sent with the upload.
The host is run by someone else, under its own terms and privacy policy. Limerino has no control over how long it keeps an uploaded image, who can see it, or what it logs. An uploaded image is on the public internet.
Limerino keeps the deletion link the host gives back, on this device only, so the image can be removed later.
If you point the setting at your own server instead, your image goes there, and any key you enter for it is kept in this device's Keychain.

To turn it off: Settings → Links & images → Image uploads → toggle off Upload images.

Reporting (handled by Twitch)

Limerino lets you report an objectionable chat message or user (long-press a message → Report message, or open a user → Report). Because Twitch hosts and moderates the content on its own platform, the in-app Report action opens the reported user's Twitch page in your browser, where Twitch's own reporting controls are, and you complete the report with Twitch.

Limerino does not collect, store, or transmit your reports. Nothing about a report is recorded on the device or sent anywhere by Limerino — no Limerino-operated endpoint receives reports.
You can also Block the user immediately. Blocking takes effect right away on this device and stops that user's messages from showing in the app. It also mutes that user's mention notifications. That mute is part of your mention-alert settings, so it travels with them to the mention-alerts server when they sync (see Muted-sender sync above); unblocking removes it the same way.

Limerino ships three companion surfaces that need to hand a channel to the main app: the Share extension (share a Twitch link into Limerino from another app), the home-screen widget, and a Live Activity. iOS runs each of these as a separate process, so they exchange data with the main app through a private App Group container (group.com.themizeguy.limerino):

The Share extension writes the channel login you shared into the App Group so the main app can open it on next launch.
The widget and Live Activity persist a small channel snapshot (login, display name, live/title/viewers used to render the tile) to the same App Group.

This container is part of the app's own private storage. It is local-only — none of it is uploaded anywhere, and it is removed when you uninstall the app.

Siri & Shortcuts ("Open channel in Limerino")

Limerino offers an Open channel in Limerino App Shortcut. When you invoke it, the channel login you speak or type is donated to the system so Siri / Spotlight / Shortcuts can route it back into the app. This donation stays on your device and is handled by iOS; Limerino does not send it anywhere.

To remove donated shortcuts: delete them in the iOS Shortcuts app, or offload/uninstall Limerino.

Removing your data

Limerino has no first-party account — you sign in with Twitch's own login — so there is no separate "delete account" step. You remove what Limerino stores on-device like this:

Clear it in the app deletes the saved copy from the device: Whispers → Clear (your stored DMs, those fetched from Twitch included; it keeps only the time you cleared, so they are not fetched again) and the Inbox → Clear (saved mentions / highlights).
Sign out (Settings → Account → Sign out) removes that account's Twitch tokens from the device Keychain and asks Twitch to revoke the access token (best effort). It also clears the video player's Twitch web session, removes this device's alert registration from Limerino's server, and removes what the app added for that account to Spotlight, Siri and Shortcuts, widgets and Live Activities. Everything else the account kept on this device stays, for that account alone, and comes back when you sign back in: its settings, open channels, chat logs, whispers and Inbox, unsaved profile edits, a linked 7TV or StreamElements account and any key for your own image host. Signing out deletes nothing else Limerino's server holds (see below).
Remove the account (Settings → Accounts: swipe the account and delete it) deletes its sign-in and everything it kept on this device: its settings, open channels, chat logs, whispers and Inbox, unsaved profile edits and any key for your own image host. Its list of the clips you created in Limerino, and any chat background photo only it used, are deleted the next time the app starts. It disconnects a linked 7TV account, ending that session on 7TV and deleting its stored token (see 7TV account linking). It disconnects a linked StreamElements account too, asking StreamElements to revoke its tokens and deleting them (see StreamElements account linking). Removing the account you are signed in with also signs you out, as above. It deletes nothing more on Limerino's server than signing out does.
Uninstall the app removes Limerino's entire on-device sandbox, for every account: every SwiftData store (open channels, settings, whispers, Inbox), the per-channel chat-log files, and the shared App Group container.

iOS Keychain items can survive an uninstall in some configurations, so remove the account first (see Remove the account above) if you want to be certain your Twitch tokens, and linked 7TV and StreamElements ones, are gone. Signing out deletes the Twitch tokens but keeps three of the account's Keychain items, so they work again when you sign back in: a linked 7TV account's token, a linked StreamElements account's tokens, and any key you entered for your own image host (see Image uploads). Removing the account deletes all three. Either way, a few more Keychain items stay behind, none of them a Twitch, 7TV or StreamElements token: for each account that has signed in on this device, the session Limerino's server issued it (a credential for Limerino's server only, which stops working a day after it is issued, kept so that after you sign out the app can still remove this device's alert registration for that account from the server), and a note naming the account whose session is newest; the random ID that labels this device's alert-keyword list (see Alert keywords above), which points at nothing on the server once that device's list is deleted there; and, if removing this device's alert registration fails when you sign out (while offline, for example), the record of that registration (its push token, the account it was for, and the one-time code that lets the app remove it after you have signed out), until the app manages to remove it. It tries each time the app starts or comes back to the screen, signed in or out, and gives up after seven days if the server will not accept the removal. There is no single in-app "erase everything" button today; apart from those items, the steps above are the complete removal path.

Data the Limerino server holds — the identity row and Mention Vault that signing in creates, the device push token, followed-channel list, notification preferences and alert keywords that using mention alerts adds, the live-alert channels and choices that turning on live alerts adds, the Twitch badge alert choice that turning on Twitch badge alerts adds (with its records), the Twitch badge ids that opening Badges or Earnable now or a badge alert adds, and the stored link that linking a Discord account adds (which Unlink on your profile or in Settings → Discord also removes on its own — see Discord account linking) — is deleted on demand from Settings → Mention Vault & data → Your data while signed in (the delete acts on the signed-in account, so sign back in first if you have signed out), and is also deleted automatically once your account goes idle for 90 days with no mention-alert entitlement recorded (see Mention alerts & Mention Vault above for the exact condition). Chat badges are the exception to that clock: a badge the Limerino team gave you (your Twitch user-ID, the Twitch username it matched, the optional note, who gave it and when) and the change-log entries naming you are not removed by the 90-day idle clean-up — a given badge stays until it is revoked or deleted, or you delete your server data, and the change-log entries naming you stay until you delete your server data. Your choice of which Limerino badge shows (your Twitch user-ID, the badge you picked or None, and when you chose) stays through the idle clean-up only while you still hold such a badge, and goes when you delete your server data (see Limerino chat badges). Signing out revokes our copy of your token and removes this device's push registration; it does not, on its own, delete the identity row or Mention Vault already stored, nor stop the server-side monitoring while that row exists — use the in-app delete to remove it now, or leave the account idle for the 90-day reap. Your notification preferences, followed-channel list, live-alert channels and choices, and a linked Discord account stay too, and so does this device's alert-keyword list until the 30-day clean-up described under Alert keywords. Your Twitch badge alert choice stays as well, for your account's other devices and your next sign-in, and so do the Twitch badge ids kept while either switch is on; the server stops reading them again once no device of yours takes these alerts. The three badge counts kept under your Twitch username are not linked to your account, so deleting your server data does not reach them: they go once they have not been read for 30 days (see Twitch badges you can earn, and the ones you have). Removing the account from this device deletes nothing more on the server than signing out does.

StreamElements account linking adds nothing to the data Limerino's server holds: while a link is in progress it keeps one short record of it (a random code, your Twitch user-ID, the permissions asked for and a one-time secret), deleted when the link finishes and otherwise at the next daily clean-up, and it never stores a StreamElements token or any detail of your StreamElements account (see StreamElements account linking).

Data Twitch holds is Twitch's, not ours. Limerino is a third-party Twitch client. Your Twitch account, every chat message you send, your follows, and your watch activity are stored on Twitch's servers under Twitch's own privacy policy — not by Limerino, and Limerino cannot delete them. Signing out of Limerino, or deleting everything Limerino holds, removes nothing from Twitch and does not delete your Twitch account or anything you posted to Twitch. To remove or request data that Twitch holds, use Twitch's own account settings and privacy process at twitch.tv.

What Limerino does not do

No analytics SDK of Limerino’s own, and no crash-reporter pinging an outside server. Two reports leave the device without you asking for each one, both only while a live stream plays on the Native player and both described in the summary at the top of this policy: the video engine’s own playback report — Amazon’s collection, for the Amazon-owned engine behind Twitch’s own player, not Limerino’s — sent to player.stats.live-video.net; and the once-a-minute watch-time report sent to Twitch while the stream is on screen, the same one Twitch’s own player sends. Neither goes to a Limerino server.
No advertising IDs, no ATT prompt, no tracking domains. The privacy manifest declares this and the assertion is regression-tested.
No background uploads of your activity or content from your device. The background data flows are the mention-alert monitoring described above, which the server runs while your identity row exists — it starts at sign-in and, because signing out does not delete that row, continues until you delete it or the 90-day idle reap removes it (the Mention Vault it fills is deleted on demand, or by that reap — see Mention alerts & Mention Vault above), and which also looks for your alert keywords — and, while you have live alerts on, the server's check of whether the channels you chose are live, made with its own Twitch credential — and, while the server offers Twitch badge alerts, its check of Twitch's public list of chat badges, made the same way, which involves nothing about you, and, while either of your Twitch badge alert switches is on and a device of yours takes these alerts, its read of your Twitch badges about once a day, by your Twitch username and with no sign-in token (see Twitch badges you can earn, and the ones you have above). None of these uploads anything from your device. The other things that go to a Limerino server are the bug reports and feature suggestions you send yourself from Settings (see Bug reports & feature suggestions above), which happen only when you tap Submit; linking or unlinking a Discord account, if you use it (see Discord account linking above); linking a StreamElements account, or renewing its access while one is linked, if you use it (see StreamElements account linking above); the Twitch message IDs of Inbox entries you have read, each time the app opens or comes back to the foreground while you are signed in (see Mentions & highlights Inbox above); a request for your Twitch badge alert choice, carrying only your mention-alerts session, each time the app opens or comes back to the foreground while you are signed in, and the choice itself when you change it (see Twitch badge alerts above); when you open a chatter's user card, a request made with your mention-alerts session naming the channel you are watching and that chatter's public Twitch user-ID; when you open Badges or retry there, and again just after you link or unlink a Discord account if you have opened it since the app started, a request made with your mention-alerts session for your own badges, and, when you choose which of them shows, your choice, sent the same way (see Limerino chat badges above); when you open Badges or Earnable now, or refresh either, a request for your own Twitch badges and the list of Twitch badges that can be earned right now, made with your mention-alerts session and carrying nothing else about you (see Twitch badges you can earn, and the ones you have above); and, while you have chat open or watch a video or clip with its chat replayed, the chat-badge lookups — the numeric Twitch user-IDs of the people chatting there, and yours when you open Badges, while your linked Discord account is on screen (your profile, or Settings → Discord), or just after you link or unlink a Discord account, with no token (see Limerino chat badges above). An image you attach or paste in chat goes to the image host set under Image uploads — never to a Limerino server — and only in the foreground, at the moment you attach or paste it yourself. That feature is on unless you turn it off, and being on sends nothing by itself (see Image uploads above). A change you make to a 7TV emote set goes to 7TV — never to a Limerino server — and only at the moment you make it (see 7TV account linking above). A change you make to a StreamElements bot goes to StreamElements — never to a Limerino server — and only at the moment you save it; a channel's bot settings are read only while its bot controls are open, and your roles and your own bot's status when a link finishes, when chat first opens after the app starts or you sign in, and when you open the StreamElements screen or refresh it or your profile (see StreamElements account linking above). A redemption goes to Twitch — never to a Limerino server — and only at the moment you choose it (see Channel Points above). An emote unlock goes to Twitch the same way, only when you tap Unlock, and the emotes an unlock reward can unlock are read, with no token, only when its screen opens or you tap Try again there (see Channel Points above). A follow, an unfollow or a watch-bonus claim goes to Twitch — never to a Limerino server — only when you tap it or type its command, from Twitch's own page in the app (see Follow, unfollow and the watch bonus above). The Channel Points sheet reads your balance and the channel's rewards while it is open, and the same request runs about every two minutes while another channel's chat is on screen when Limerino can't check that channel's predictions, so your balance can show at the top of chat (see Channel Points above); your balance is also read with another channel's predictions while its chat or Predictions screen is on screen (see Predictions above), and with a poll while its sheet is open (see Voting in a poll above). The names and costs of a channel's rewards are read once, with no token, when a redemption shows in chat (see A channel's public chat details above). A prediction you place, start, lock, choose a winner for or cancel goes to Twitch — never to a Limerino server — and only at the moment you choose it, and another channel's predictions are read only while its chat or Predictions screen is on screen (see Predictions above). A channel's other public chat details, and your standing and chat access there, are read only while its chat is on screen, never in the background (see Your standing and chat access in a channel above). A chatter's moderator history is read only while its page is open, your Twitch badge only when you open its screen or tap Try again there, and your whisper history only when you open Whispers or a conversation (see Moderator history on a user card, The Twitch badge you wear and Whispers / direct messages above). Any other change you make on Twitch from Limerino goes to Twitch — never to a Limerino server — only at the moment you choose it, and a read that goes with one runs while its screen is open, or once after you send it to check what Twitch did, even if you have left that screen by then (each is described with its feature above). Reporting objectionable chat opens the reported user's Twitch page; Limerino keeps no copy, and nothing about a report leaves the device in the background. No location access. No camera access. No microphone access. No contact access. No HealthKit / HomeKit / Motion / Bluetooth.
Limerino never logs your access token, refresh token, or any secret.

How the data leaves the device

Scroll sideways for the full table.

Every destination Limerino contacts, when it contacts it, and what it sends
Destination	When	What
`irc.chat.twitch.tv` (Twitch)	When signed in	TLS IRC frames for the channels you open, signed with your saved Twitch sign-in; chat you send
`api.twitch.tv` (Twitch Helix)	After the app validates your signed-in Twitch account	Documented OAuth-authenticated REST calls for identity, search, follows, stream and clip details, creating clips, chat settings, emotes, badges, moderation, and predictions in your own channel
`id.twitch.tv` (Twitch OAuth)	During sign-in, token refresh, periodic token validation, the player-session account check (run again after any sign-in in the app, before a Channel Points, Predictions, moderator history or Twitch badge request, or a change you make on Twitch from Limerino and the reads that go with it, when your sign-in or the web session has changed since the last check, and if Twitch answers one of those requests as a different account), and — if you connect a 7TV account — the authorization page for that grant	OAuth handshake and validation; the web session's account-verification check; and, for a 7TV link, Twitch's own authorization page loaded in a secure in-app web view, where you approve the grant
`api.limerino.com` (Discord linking)	When you link, check, or unlink a Discord account; and, while you are signed in, when Settings or your profile opens or the app returns to the foreground with either open, to read whether a Discord account is linked, at most once a minute after an answer	The one-time Discord authorization Limerino's server brokers for you, and the link it then stores: your Discord user id, username and avatar hash, whether your Discord account has a verified Twitch connection matching this one, and whether you joined the Limerino Discord server. Limerino asks Discord to revoke your token inside that same request; the token is never stored either way (see Discord account linking)
`api.limerino.com` (StreamElements linking)	When you link a StreamElements account; and, while one is linked and you use the app, when its tokens have fewer than seven days left or StreamElements turns the current one down	Over your mention-alerts session: a request to start a link, which the server answers with StreamElements' authorization address, keeping one short record of the start (a random code, your Twitch user-ID, the permissions asked for and a one-time secret) until the link finishes or, at the latest, the next daily clean-up; the one-time authorization code, which reaches the server's return address in the browser sheet, goes straight back to the app without being stored, and is then sent by the app to finish the link; and, to renew, your current StreamElements refresh token. The server exchanges these with StreamElements and answers with your StreamElements tokens and the account's id, name and display name, its Twitch user-ID and the permissions you approved, once it has checked that the account belongs to the Twitch account you are signed in with. It stores no StreamElements token or account detail, and if a check fails it asks StreamElements to revoke the new tokens (see StreamElements account linking)
`api.limerino.com` (chat badges)	The badge list: at app start; again when you return to the app, on network recovery, or at sign-in, if that fetch failed or is more than ten minutes old; when the app reads your own Limerino badges, unless the list was fetched in the last minute; and, when a lookup answer names a badge the list does not have yet, at most once a minute (the read of your own badges counts too). Badge images: when a badge is drawn. Badge lookups: while you have chat open, while you watch a video or clip with its chat replayed (signed in or out), when you open Badges, while your linked Discord account is on screen (your profile, or Settings → Discord), and just after you link or unlink a Discord account, in batches, for accounts it has had no answer about in the last ten minutes (an account that showed a badge) or thirty minutes (one that showed none), keeping up to 10,000 answers	Public fetches of Limerino’s chat badge list — each badge’s name and images, and a short note on what it stands for and how to get it — and of the badge images themselves; and public lookups by numeric Twitch user-ID for the authors of the messages and notices shown in the channels you have open and in the chat replayed with a video or clip, the sender of a direct message mirrored into your channel tabs included (yours too, when your own messages are among them, when you open Badges, while your linked Discord account is on screen, or just after you link or unlink a Discord account), up to 100 per request and at most one request every two seconds, in the body of the request rather than its web address, with no token — neither your Twitch sign-in token nor your mention-alerts session. What comes BACK is which Limerino badges each of those accounts shows — every badge it holds, the one its owner picked listed first if they picked one, or nothing if they chose None — and nothing else. Nothing else about you or your account is sent; `api.limerino.com` receives your device's IP address, as any server your device contacts does
`discord.com` (Discord)	When you tap Link Discord	Discord's own authorization page — and its sign-in page if you are not signed in there yet — opened in a system browser view that shares Safari's Discord session, so you approve on Discord's pages and not in Limerino. The page Limerino opens carries only its own Discord application id, the permissions it asks for, a one-time nonce, the `api.limerino.com` address Discord returns you to, and a one-time cryptographic challenge that lets Limerino's server prove the reply belongs to that same request; nothing about your Twitch account, and no token
`cdn.discordapp.com` (Discord)	When a linked Discord account's profile picture renders on your profile or in Settings → Discord	Your Discord user id and avatar hash, in the image address → the picture itself. No token, and nothing about your Twitch account
`eventsub.wss.twitch.tv` (Twitch)	When signed in	Live stream / moderation event push, and your own channel's prediction events, subscribed while its Predictions panel is open
`player.stats.live-video.net` (Amazon IVS Player — the live video engine)	While a live stream is playing in the app's player	The engine's own playback report. Its privacy manifest declares that the engine collects an identifier it assigns to the viewing session (Apple's User ID category), the interactions you make with the player, performance figures such as buffering and bitrate, other diagnostic details about the playback, and a residual category listed only as "other data types", for the engine's analytics and for playback itself — Amazon's collection, for the Amazon-owned engine behind Twitch's own player, not Limerino's. Not linked to your identity, never used for tracking, and sent only on the Native player — choosing Embedded under Settings → Video → Player type stops this engine's report, and Twitch's own web player then reports to Twitch instead (see the summary at the top of this policy, and Twitch authentication)
Twitch (watch-time report)	Only while a live stream plays on the Native player and is on screen: once for each full minute it plays, never while it is paused, buffering, covered by Settings or another screen, or in the background, and never on the Embedded player	The watch-time report Twitch's own player sends, so your watch time and channel points count: your Twitch user ID, the channel's name and ID, the stream's ID and category, whether the player is muted, the time, and fixed values saying a signed-in viewer is watching live on the channel, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server; a minute that was not watched is never reported, and nothing missed is sent later
Twitch (Channel Points)	While the Channel Points sheet is open: when it opens, about once a minute while it stays on screen, and at most once after a redemption, an emote unlock or a watch-bonus claim; a redemption or an unlock only when you tap it; the emotes an unlock reward can unlock when its screen opens or you tap Try again there, never twice within 10 seconds; for your balance at the top of another channel's chat when Limerino can't check its predictions (Predictions off, for example), when that chat opens unless your balance there was read in the last two minutes and about every two minutes while it stays on screen, never for your own channel or in the background; none while Channel Points is off in Settings	Your request — the channel's Twitch name or ID; for a redemption the reward's ID, cost, title and prompt, any message you typed and a random transaction ID; for an emote unlock the reward's cost, a random transaction ID and, for an emote you chose, its ID — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server; the list of emotes an unlock reward can unlock is asked for with the channel's name alone and no token, cookie, device ID or session ID. Your balance, the rewards and that list stay in memory only, an unlocked emote for 24 hours, and nothing is stored (see Channel Points); a watch-bonus claim is in the next row
Twitch (follow, unfollow and watch-bonus claims)	Only when you tap Follow on a user card, confirm an unfollow there, type `/follow` or `/unfollow`, or tap Claim bonus in the Channel Points sheet: at most one request per tap or typed line, never by itself; then, for a follow or an unfollow, up to three `api.twitch.tv` checks and one refresh of your followed channels; none while Follow and unfollow (for a follow or an unfollow), Claim watch bonuses or Channel Points (for a claim), or Web features is off in Settings	Your request — the person's Twitch ID for a follow or an unfollow; for a claim, the channel's ID and the bonus's ID — sent from Twitch's own page, `www.twitch.tv/popout/<name>/viewercard/<name>`, opened for that one request in a web view beneath Limerino's screen, with the player's Twitch web session, the device identifier Twitch itself set in it, a session identifier made for that page and the web view's standard browser identification. That page first asks Twitch for its integrity token, with the same identification, and the request carries it; the token never leaves that page. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server; Twitch's answer stays in memory only (see Follow, unfollow and the watch bonus)
Twitch (sharing a resub)	While the Channel Points sheet is open in a channel you subscribe to that isn't yours, after your points load: whether you have a resub to share, once each time the sheet opens, reusing an answer for a minute and never twice within 10 seconds, and once more when you open the share screen on an older answer; a share only when you tap Share in chat, or Try again after Twitch did not confirm it; after a share Twitch did not confirm, one check while the share screen is open, at least 10 seconds after the last	Your request — the channel's Twitch name for the check; for a share, the channel's Twitch name, Twitch's ID for your resub, whether to include your streak and any message you typed — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server; Twitch posts the share in that channel's chat for everyone there, and what Twitch answers stays in memory only (see Sharing a resub in chat)
Twitch (Predictions)	In a channel that isn't yours, while its chat or Predictions screen is on screen: when it opens, every 15 seconds while a prediction there is taking points, every 30 seconds while one is waiting for its result, every minute otherwise, once after anything you send, and when you pull to refresh or tap Try again; never for a channel that isn't on screen, and never in the background. A prediction, or as the channel's moderator a start, lock, winner or cancel, only when you tap it; your acceptance of Twitch's prediction terms only when you tap Accept terms; in a channel that isn't yours, none while Predictions is off in Settings	Your request — the channel's Twitch name for the read; for a prediction, the prediction's and outcome's IDs, the points you chose and a random transaction ID; for a start, its question, outcomes and prediction window; for a lock, winner or cancel, the prediction's ID and the winning outcome's ID; for Twitch's prediction terms, your acceptance — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server; what Twitch answers, your balance there included, stays in memory only, and nothing is stored (see Predictions)
Twitch (polls you run as a moderator)	In a channel you moderate that isn't yours: a new poll only when you tap Start in its form, the end of a running poll only when you confirm End poll, and either again only when you tap Try again after Twitch did not confirm it	Your request — for a start, the channel's Twitch ID, the question, the choices, how long it runs and whether Channel Points can add votes, with their cost; for an end, the poll's ID — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server; nothing is stored (see Polls you run as a moderator)
`7tv.io`	At app start for global emotes; when a signed-in channel loads for channel emotes	Public 7TV emote-set fetches (cosmetics come from `events.7tv.io` and `api.7tv.app`)
`api.7tv.app` (7TV)	When you sign in, each time the app returns to the foreground, and when you turn 7TV back on in Settings (your own cosmetics, and — while Show personal emotes is on, which it is by default — your own personal emote set); and for anyone whose name Limerino draws in chat, and (while Show personal emotes is on) for anyone whose messages it draws — chatters in a channel you have open, the sender of a direct message mirrored into your channel tabs, the subject of a sub / raid / ban / redemption / went-live notice, and the chatters in a VOD's replayed chat as their messages reach the playhead (theirs); and, only if you link a 7TV account: when the 7TV account row in Settings first appears and when a connection finishes — each reading who that 7TV account is — and whenever you open the emote-set screens, the name-paint screen or the 7TV badge screen, search the emote directory, or make a change there; when chat contains a 7TV emote page link (`7tv.app/emotes/…`) and Inline link previews is on (it is on by default) — including links other people post; and whenever you tap such a link, which is navigation rather than a preview and so happens whether or not that setting is on. Both of those need 7TV emotes & name colors to be on (it is on by default): with it off, a 7TV emote link is an ordinary link and Limerino looks up no emote for it at all	Public 7TV lookups by numeric Twitch account id — yours, and those of the people whose names are drawn on screen, including a direct-message sender who is not in any channel you have open — in batches, with no token. Two separate things are asked for. Cosmetics: this is what lets your OWN 7TV paint and badge appear, which the `events.7tv.io` socket can never deliver; what comes BACK is the paint and badge each account currently wears (their definitions and artwork addresses) and nothing else about that account — deliberately not their linked Discord or Kick account ids, which this route would otherwise return. Personal emotes, only while Show personal emotes is on (it is on by default, and it needs 7TV emotes & name colors on as well): what comes BACK is that account's 7TV account id and the emote sets 7TV has approved them to wear in any channel — each emote's name, the name that account wears it under, the addresses of its artwork, and the display name of whoever uploaded it. Turning Show personal emotes off stops that half completely: no such request is made for anyone, including you. Limerino keeps both answers in memory for the session, and never stores or forwards any of it. Only if you link a 7TV account, this host also carries that feature. Without your sign-in: the public 7TV profile and owned emote sets of a channel you manage, the contents of one set, and the emote directory you search — including the words you type into the search box. With your 7TV sign-in token: who your 7TV account is, which channels have made you an editor and what those editor rights allow, your own account's emote-set limits, which name paints and which 7TV badges your own account owns and which of each it currently wears, and every change you make — the set id, the emote id where one is involved, the paint's id when you choose a name paint, the badge's id when you choose a 7TV badge (clearing either sends an explicit empty value, not an id), any name, tag, emote-slot count or active-set choice you made, the 7TV account id of the channel when you create a set or choose which of its sets is active, and your own 7TV account's id when you choose a name paint or a 7TV badge (see 7TV account linking). A 7TV emote page link in chat is looked up the same way: the request carries only that emote's public id — no token, and nothing about you. What comes BACK is the emote's public name, its uploader's display name, the addresses of its artwork, and whether 7TV lists it publicly and marks it mature; Limerino keeps that in memory for as long as it is drawing that message and never stores or forwards it. 7TV can see your IP address, as any site you contact can
`api.7tv.app/v4/auth/*` (7TV)	Only when you connect or disconnect a 7TV account	Starting a link sends nothing about you: 7TV answers with the address of Twitch's own authorization page. Finishing it sends the one-time authorization code Twitch handed back, which 7TV exchanges for a session token kept in this device's Keychain. Disconnecting asks 7TV to end that session, naming the token being ended, and Limerino deletes the stored token either way (see 7TV account linking)
`api.streamelements.com` (StreamElements)	Only if you link a StreamElements account: when a link finishes, the first time chat opens after the app starts or you sign in while Show bot controls in chat is on, and when the StreamElements screen opens, to read your roles; when you pull to refresh your profile or the StreamElements screen; when you open a channel's bot controls, and again when you pull to refresh there, come back to the app with them open, or save; when you make a change; and when tokens are replaced or you disconnect	With your StreamElements sign-in token, or a manager session StreamElements issues for a channel you help manage: the channels where StreamElements gives you a role, and the role (each row also carries the channel's picture address, which Limerino drops); each of those channels' public StreamElements profile, to match it to its Twitch channel; whether your own bot is in your chat and, while it is not, whether it has any commands or timers; a request for a manager session for the channel whose bot controls you open, which Limerino keeps in memory for at most an hour; that channel's bot status, timers, commands, built-in commands, spam filters and banned phrases, modules, Regulars and Super Moderators, counters and quotes (the Regulars list carries each viewer's last chat message, which Limerino drops); every change you make — the id of the item and what you typed or chose, and, when you add a Regular or Super Moderator, that viewer's Twitch user-ID; a check that a token still works, made only before the app treats a link as ended; and, to revoke a token, that token and Limerino's own StreamElements app id. Only the tokens are kept, in this device's Keychain (see StreamElements account linking). StreamElements can see your IP address, as any site you contact can
`streamelements.com` (StreamElements)	When you tap Connect StreamElements on the StreamElements screen and continue	StreamElements' own authorization page — and its sign-in page if you are not signed in there yet — opened in a system browser sheet that shares Safari's StreamElements session, so you approve on StreamElements' pages and not in Limerino. The address Limerino opens starts at `api.streamelements.com/oauth2/authorize`, which forwards to this page, and carries only Limerino's own StreamElements app id, the permissions it asks for (reading and changing your bot's settings), a random code that ties StreamElements' reply to this start, the `api.limerino.com` address StreamElements returns you to, and a one-time cryptographic challenge that lets Limerino's server prove the reply belongs to that same request; nothing about your Twitch account, and no token
`api.betterttv.net`	At app start for global emotes; when a signed-in channel loads for channel emotes	Public BTTV emote-set fetches and global badge metadata
`api.frankerfacez.com`	At app start for global emotes; when a signed-in channel loads for channel emotes	Public FFZ emote-set and badge fetches
`api.chatterino.com`	At app start; again when you return to the app, on network recovery, or at sign-in if that first attempt failed	Public supporter-badge roster fetch for the Chatterino project. No token and nothing about you: the whole short list comes back, and your device matches it against the Twitch account ids already drawn on screen — no account id is ever sent
`api.moltorino.com` (Moltorino badges)	At app start; again when you return to the app, on network recovery, or at sign-in, if that first attempt failed or the last fetch is more than fifteen minutes old	Public supporter-badge roster fetch for Moltorino. No token and nothing about you: the whole list comes back, and your device matches it against the Twitch account ids already drawn on screen — no account id is ever sent
`chatterinohomies.com` (Chatterino Homies custom badges)	While the Homies custom badges setting is on (it is on by default): at app start and when you turn it on; again when you return to the app, on network recovery, or at sign-in if that attempt failed	Public fetch of the Chatterino Homies custom badge list: badges people upload to Chatterino Homies for themselves. No token and nothing about you: the whole list comes back, and your device matches it against the Twitch account ids already drawn on screen — no account id is ever sent
`itzalex.github.io` (Chatterino Homies badges)	At app start; again when you return to the app, on network recovery, or at sign-in if that first attempt failed	Public fetches of the two Chatterino Homies badge rosters, supporters and staff. No token and nothing about you: both whole lists come back, and your device matches them against the Twitch account ids already drawn on screen — no account id is ever sent
`static-cdn.jtvnw.net` (Twitch)	When chat renders Twitch emotes / badges; when the Channel Points sheet shows reward pictures, the channel's points icon and the emotes an unlock reward can unlock; when the video pane shows a stream's poster; and, in multi-view, for each still's live preview, refreshed about every five minutes while the grid is on screen	Emote / badge id, or the picture's address → image bytes (no token, nothing about you)
`d3aqoihi2n8ty8.cloudfront.net` (Twitch)	When chat renders bits / cheermotes	Cheermote id → image bytes
`cdn.7tv.app` (7TV)	When chat renders 7TV emotes and badges or draws an image name paint, when the emote-set screens or the emote directory render artwork, when the name-paint screen loads previews of the image paints your account owns, and when the 7TV badge screen loads the art of the badges your account owns	Emote id, paint or badge artwork address → image bytes
`media*.giphy.com` (GIPHY)	When a GIF someone sent in chat scrolls into view and Show GIFs sent in chat is on (it is on unless you turn it off)	The request for that GIF, at the address Twitch supplied, including the analytics parameters GIPHY puts in its own links → the image bytes. No account and no token, and nothing about you rides the request; GIPHY can see your IP address, as any site you load a picture from can. With the setting off, nothing is requested
`events.7tv.io` (7TV)	Socket opens at app start; channel subscriptions begin after signed-in channel hydration	Live emote-set updates, plus the channel's 7TV cosmetics (username paints). Only channel-level identifiers are sent — the channel's public 7TV emote-set id (live emote updates) and the channel's numeric Twitch id (cosmetics); no token and no separate viewer identifier (though if you open your own channel, its channel id is by definition your public Twitch account id). What comes BACK includes other chatters' public 7TV profile fields (7TV username / display name, avatar URL, role ids, and their linked Discord or Kick account ids); Limerino reads only the paint and the Twitch account id, keeps it in memory for the session, and never stores or forwards any of it. This socket announces nobody, so it never carries YOUR cosmetics — those are fetched from `api.7tv.app`
`cdn.betterttv.net` (BTTV)	When chat renders BTTV emotes or badges	Emote or badge id → image bytes
`sockets.betterttv.net` (BTTV)	Socket opens at app start; channel subscriptions begin after signed-in channel hydration	Live emote updates, by the public id of each channel you open. While Show badges and BetterTTV global badges are on (both are on unless you turn them off) and you're signed in, Limerino also tells BetterTTV your Twitch user ID and the channel you open, each time it joins that channel, so your BetterTTV Pro badge can show to you and to other BetterTTV users in that channel, and other people's Pro badges can show to you. What comes BACK, for each BetterTTV Pro user in that channel (you included), is their Twitch user ID and name, their Pro badge's image address and their other BetterTTV Pro settings; Limerino reads only the user ID and the badge image address, keeps them in memory for the session, and stores only your own on this device, until you sign out or switch account; that copy is rebuilt from what BetterTTV sends in the next channel you open. No token. BetterTTV can see your IP address, as any site you contact can
`cdn.frankerfacez.com` (FFZ)	When chat renders FFZ emotes / badges	Emote id → image bytes
`fourtf.com` (Chatterino badges)	When chat renders a Chatterino supporter badge	Badge image address → image bytes. No account and no token
`api.moltorino.com` (Moltorino badge images)	When a Moltorino supporter badge is drawn	Badge image address → image bytes. No account and no token
`itzalex.github.io` (Chatterino Homies badge images)	When a Chatterino Homies supporter or staff badge is drawn	Badge image address → image bytes. No account and no token
`cdn.chatterinohomies.com` (Chatterino Homies custom badge images)	When a Chatterino Homies custom badge is drawn	Badge image address → image bytes. No account and no token. Each custom picture belongs to one person, so the request shows that host which holder's badge your device is drawing
`i.imgur.com`, `pbs.twimg.com`, `cdn.discordapp.com`, `clips-media-assets2.twitch.tv` (image link previews)	When chat contains a link to one of these hosts and Inline link previews is on (it is on by default) — including links other people post	The request for that picture → the image bytes. No account and no token; the host can see your IP address, as any site you load an image from can
`kappa.lol`, `segs.lol`, or the image host you configure (image-host pictures)	ONLY when Pictures from image hosts is on — it is off unless you turn it on. With it off, a link to one of these hosts is just a link and your device contacts nothing. With it on, it behaves like the row above, including for links other people post; your own configured host joins the list only while Image uploads is also on	The request for that picture → the image bytes. No account and no token; the host can see your IP address, as any site you load an image from can
`kappa.lol` / `segs.lol`, or the image host you configure (image uploads)	When you attach or paste an image yourself in the message box. Image uploads is on unless you turn it off, and the attach or paste is what sends the image — nothing goes anywhere without it. While it is on, the host you configured joins the image-host pictures row above whenever that setting is on	The image you chose, with its location and camera information removed on your device first. No account, no token, and nothing about your Twitch identity. The host returns a public link, which Limerino puts in your message box for you to send or delete. If you point this at your own server instead, your image goes there
`recent-messages.robotty.de`	When signed in and you open a channel (if backfill enabled)	Channel name → recent scrollback from before you joined
`api.ivr.fi` (IVR)	When you tap a chatter's name, to fill in the user card's follow and subscription details	That chatter's public Twitch name and the name of the channel you are watching → their public subscription standing in that channel. No account and no token — though if the chatter whose card you open is yourself, that name is by definition your own public Twitch name. A subscription the chatter has hidden on Twitch is not shown. How long they have followed the channel comes from Twitch's own API instead (the `api.twitch.tv` row above), and only where Twitch lets you ask. Kept in memory for the session, never stored or forwarded; the service can see your IP address, as any site your device contacts can
`api.pronouns.alejo.io` (alejo.io pronouns)	Only while Show pronouns on user cards or Show pronouns in chat is on (both are off unless you turn them on): when you open a chatter's card, and for the people whose messages you see in chat, at most once an hour each (two minutes after a lookup that failed)	Each person's public Twitch username → the pronouns they published there, or none; and, once each time the app runs, the service's public list of pronoun sets. No account and no token — though if the person is you, that username is by definition your own. Kept in memory while the app runs, never stored or forwarded; the service can see your IP address, as any site your device contacts can
`itunes.apple.com` (Apple)	Once per app launch	App Store version lookup for the one-time update notice: the app's public bundle id and your device's region setting. Nothing about you or your account
`limerino.com` (Limerino sign-in bounce)	Only if the legacy web sign-in runs — not part of the current sign-in flow	Loads Limerino's OAuth redirect bounce page, which forwards the Twitch login result to the app; your token rides the URL fragment and is not received by the server
`api.limerino.com` (mention alerts — session)	When you sign in (establishes your mention-alerts session; monitoring begins), and again whenever that session has lapsed, at the next request that needs it. Over that session too: when you open Badges or retry there, just after you link or unlink a Discord account if you have opened it since the app started, and when you choose which Limerino badge shows beside your name	Your Twitch access token, checked against Twitch to confirm who you are then discarded (never stored); the identity row kept for you (Twitch user-ID, login/display name, mention-alert entitlement state); Mention Vault entries the server records for you (message text and id, channel and its Twitch channel-ID, chatter login/display name/user-ID, name color, badges, emotes used, timestamp, and — for a message that carried a GIF sent through Twitch's built-in GIF feature — Twitch's GIF tag exactly as it supplied it: the picture's address, its GIPHY id, and where the caption sits in the message); optional blocked-user ID sync; optional muted-sender ID sync (users you mute for notifications, including anyone you block in the app); and, for Badges, a request for your own badges (which ones you hold and since when, which one you chose to show, and what lookups list for you) and the choice you make there (one badge you hold, Automatic, or None), which the server keeps as your Twitch user-ID, the badge or None, and when you chose; choosing Automatic deletes it
`api.limerino.com` (mention alerts — alert delivery)	While mention alerts are on, live alerts are on for at least one channel, or Twitch badge alerts are on	This device's APNs push token and which alerts it takes (mention alerts, live alerts, Twitch badge alerts, or any mix of them), so a matched mention, a live alert or a Twitch badge alert can be delivered here
`api.limerino.com` (mention alerts — notification settings)	When you open or adjust Notification settings, your followed channels change, you mute or block a user, you import settings that carry blocked users, a highlight rule's alert word changes while Mention push alerts are on, or you change live alerts	Your followed-channel list (names only), notification preferences (per-channel toggles, cooldowns, quiet hours + time zone, delivery mode, reply alerts, Match case), and your muted-sender list — the Twitch ID or login of each user whose mentions you have muted, blocking anyone in the app included; your alert keywords — single words from your own highlight rules, never who sent a message, with a random ID Limerino keeps for this device; and the channels you turned live alerts on for, with your live-alert choices
`api.limerino.com` (Twitch badge alerts)	Each time the app opens or comes back to the foreground while you are signed in, whether or not you turned these alerts on; and when you turn either kind of Twitch badge alert on or off	Over your mention-alerts session: a request for your Twitch badge alert choice, which sends nothing else; and, when you change it, the choice itself — whether you want alerts for badges you get by watching or clipping, and for badges that need a sub, gift sub or Bits — which the server keeps linked to your Twitch user ID. Turning a switch on while both were off starts the server's read of your Twitch badges. For each badge that could be earned when you turned these alerts on, each one an alert told you about, and each one your collection already held, the server keeps a record of your Twitch user ID, the badge and when, so the same badge is never announced to you twice (see Twitch badge alerts)
`api.limerino.com` (Twitch badges you can earn)	When you open Badges or Earnable now, pull either to refresh, tap Try again or Check again there, or come back to either after five minutes or more	A request for your own Twitch badges and the list of Twitch badges that can be earned right now, with how to get each, when it can be earned and whether you have it. It goes with your mention-alerts session, which identifies you to the server, never your Twitch sign-in token, and carries nothing else about you; the server finds your Twitch username from that session and reads your badges from Twitch by it, with no sign-in token, at most once an hour. `api.limerino.com` receives your device's IP address, as any server your device contacts does (see Twitch badges you can earn, and the ones you have)
`api.limerino.com` (recent messages on the user card)	When you tap a chatter while signed in	The channel you are watching and that chatter's public Twitch user-ID, sent over your mention-alerts session, so the card can show up to the last hour of their messages in that channel from the memory-only cache described above
`api.limerino.com` (unread mentions)	While you are signed in: each time the app opens or comes back to the foreground, about ten seconds after you read a mention while the app is open, and when you leave the app with a read it has not reported yet	Over your mention-alerts session: a request for how many of your mentions are unread, and the Twitch message IDs of Inbox entries from the past seven days that you have read, so the server can mark its copies of those mentions in your Mention Vault as seen. Only the IDs are sent, never the text, who sent it, or the channel, and the server keeps no list of them
`api.limerino.com` (Limerino feedback)	When you tap Submit in Settings → Report a Bug or Suggest a Feature	Your typed description; always basic device metadata, even with Include diagnostics off; the diagnostics report unless you turn off Include diagnostics (on by default for a bug, off for a suggestion). Every request is stored in Limerino's private backend; a request kept for follow-up is copied to the developer's private GitHub tracker with the same description, metadata, and any included diagnostics. Anthropic receives the description, basic metadata, and salted safety identifier to triage the request automatically; diagnostics never go to Anthropic. No sign-in required
`www.twitch.tv`, `player.twitch.tv`, `clips.twitch.tv` (Twitch)	The in-app device-approval page during sign-in; the video player, including clip playback; a follow, an unfollow or a watch-bonus claim, for that one request	Twitch's own activation / login / player / clip / popout card web pages, loaded in a secure web view
`www.twitch.tv` (your browser)	When you tap Report on a message / user	Opens the reported user's Twitch page in your default browser so you can report them to Twitch — Limerino sends nothing itself
`7tv.app` (your browser)	When you tap Report on an emote in the 7TV emote directory	Opens that emote's page on 7TV in your default browser so you can report it to 7TV — Limerino sends nothing itself
`*.ttvnw.net` (Twitch)	While the video player is playing	Twitch video segments from the player's own CDN
Twitch (VOD/clip chat replay)	While a past broadcast or clip plays in the in-app theater	Read-only request for that video's past chat messages, using the player's web session (or with no credential at all, when that session is missing or refused). Limerino stores none of them
Twitch (clips and past broadcasts in Limerino's player)	While you are signed in and Player type is Native: when a clip, or a past broadcast Limerino's player can play, opens in the theater; a permission is reused until it expires; never in the background	Your request — the clip's or the video's ID, and for a past broadcast a second request that hands Twitch's answer to its video server — over the player's Twitch web session (see Twitch authentication), never to a Limerino server, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. Twitch answers with permission to play the video and where to load it from, kept in memory only; the video then loads from Twitch's video servers, and no playback or watch-time report is sent
Twitch (a channel's public chat details)	While you are signed in and a channel's chat is on screen: its pinned message if you don't moderate it (when you open, switch to or come back to it, reconnect or type `/pin`, and once when a timed pin ends; at most once every 15 seconds); a check for a poll about every minute and, only while Hype Train is on in Settings (it is off until you turn it on), for a Hype Train about every two minutes, about every 15 seconds while one runs, and for the poll when you pull to refresh it or tap Try again; its reward names once, when the first redemption shows in chat, and not again until the app restarts or you sign in again; its chat rules when you open them from the rules card before your first message or from Chat rules on a warning, timeout or ban, or tap Try again there (if they fail to load, up to three more tries by itself, a minute apart, while Chat rules is open), and once the first time you tap the message box where you have never chatted; and a check of its poll once after you start or end one there as a moderator. Otherwise never for a channel off screen or in the background; in your own channel, only its poll and chat rules; and none of a detail whose switch you turn off in Settings (Show pinned message, Polls, Show reward names or Channel Points, Chat rules)	The channel's Twitch name or ID (the Hype Train check: the IDs of the channels on screen, at most 10), the app's name and version, your iOS version, and Twitch's public web client ID, plus the standard headers iOS adds to every web request, your preferred languages among them. No token, no cookie, no device ID and no session ID, and Limerino adds nothing about you; Twitch sees your device's network address, as with any request. What Twitch answers stays in memory only (see A channel's public chat details)
Twitch (voting in a poll)	In any channel, your own included, while its poll sheet is open: whether you voted, when the sheet opens unless Twitch answered about that poll in the last 15 seconds, and once after each vote, never twice within 5 seconds; a vote only when you tap Vote, an extra vote for Channel Points only when you tap Add a vote, and either again only when you tap Try again after Twitch did not confirm it	Your request — the channel's Twitch name for the check, which also asks for your Channel Points balance there and how many votes you have; for a vote, the poll's and the choice's IDs, your Twitch user-ID and a random vote ID, and for an extra vote the Channel Points it costs, shown before you tap — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server; what Twitch answers stays in memory only, and nothing is stored (see Voting in a poll)
Twitch (your chat access in a channel)	While you are signed in: when you open a channel in followers-only or subscribers-only mode, when you first tap its message box, and after Twitch refuses a message there because of a chat mode or your account; at most once a minute per channel; never in your own channel or one where you are a moderator or VIP, and never in the background	Your request, the channel's Twitch name, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server. Twitch answers the reasons, if any, it would refuse your messages there, and whether you have chatted there before, which Limerino uses only to offer the channel's rules before your first message; both stay in memory only (see Your standing and chat access in a channel)
Twitch (your standing in a channel)	While you are signed in and the channel's chat is on screen: the first time you open a channel after the app starts, you sign in or the web session changes; after Twitch refuses a message there because of a warning, timeout or ban or says in chat that you were timed out or banned (for a channel that is not on screen, once it is); while Limerino knows of a warning, timeout or ban for you there, each time you come back to that channel and once after Twitch accepts a message you send there, and for a timeout or ban also when you tap its message box; at most once every 30 seconds per channel; never for your own channel, and never in the background; it still runs while Show when you're warned or timed out is off in Settings, so the message box can say why chat refuses you	Your request, the channel's Twitch name, with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session. It goes over the player's Twitch web session, never to a Limerino server. Twitch answers whether a moderator warned, timed out or banned you there, with the reason and any rules they cited, never who did it, and it stays in memory only (see Your standing and chat access in a channel)
Twitch (acknowledging a warning)	Only when you tap Acknowledge on a moderator's warning in a channel that isn't yours, or Try again after Twitch did not confirm it; then, unless Twitch confirmed it, one read of your standing there, at least 30 seconds after the last	Your request — the channel's Twitch ID — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server; nothing is stored (see Your standing and chat access in a channel)
Twitch (moderator history)	If you moderate the channel: when you open Moderation history on a chatter's card there, at most five requests, then one each time you tap Show older (20 at a time, at most 10 pages of messages and 5 of comments) or Show comments from other channels (at most 5 pages); never the same request twice within 10 seconds, and never in the background; none while Moderation history is off in Settings	Your request — the channel's Twitch ID and that person's Twitch user-ID, and for Show older Twitch's marker for where the last page ended — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server. Twitch answers that person's current ban or timeout, past actions, messages and moderator comments in that channel, kept in memory only while the page is open (see Moderator history on a user card)
Twitch (moderator comments)	If you moderate the channel: a comment only when you tap Add on a chatter's Moderation history page, a deletion of one of your own comments only when you confirm it, and either again only when you tap Try again; then, only when Twitch's answer was uncertain, one read of that person's first page of comments, at least 10 seconds after the last	Your request — for a comment, the channel's Twitch ID, that person's Twitch user-ID and your text; for a deletion, the comment's ID and the channel's Twitch ID — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server. The channel's moderators can see your comment on Twitch; a comment you are still writing stays in memory only (see Moderator history on a user card)
Twitch (your Twitch badge)	When you open Twitch badge or Badge in this channel, or tap Try again there, at most once every 15 seconds for each; when you tap Wear this badge, unless your badges were read in the last 15 seconds; never in the background	Your request — that channel's Twitch name, or your own for the badge you wear everywhere — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server. Twitch answers which badge you wear and which ones you can wear, as badge set IDs and versions, kept in memory only (see The Twitch badge you wear)
Twitch (choosing your Twitch badge)	Only when you pick a badge on Twitch badge, pick a badge or Use my global badge on Badge in this channel, tap Wear this badge on a badge you own, choose None on Twitch badge or Stop wearing, or Try again after Twitch did not confirm one; then, unless Twitch said no, one read of your badge, at least 15 seconds after the last	Your request — the badge's set ID and version, and for one channel that channel's Twitch ID; None and Stop wearing carry neither — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server; the Badges screen shows your choice from memory until your next message shows it in chat, and nothing is stored (see The Twitch badge you wear)
Twitch (whisper history)	When you open Whispers, at most once every five minutes, and once when Try again brings whispers back after they stopped arriving; when you open a conversation, at most once a minute for it; never at launch, in the background, for a conversation that is not on screen, when whispers are turned off under Choose permissions, or while Load earlier whispers is off in Settings	Your request — for one conversation, your Twitch user-ID and the other person's — with the app's name and version, your iOS version, its per-launch session identifier and the device identifier Twitch itself set in the player's web session, and no integrity token. It goes over the player's Twitch web session (see Twitch authentication), never to a Limerino server. Twitch answers your 20 most recent conversations, or a conversation's latest 50 messages, which are saved on the device like whispers you receive and stay there across sign-out until you delete the conversation, Clear, or remove the account (see Whispers / direct messages)
On-device App Group (no network)	Share into Limerino · pin a widget / Live Activity	Channel login + channel snapshot, app-extension → app
On-device Siri donation (no network)	Use the "Open channel in Limerino" shortcut	Spoken/typed channel login, donated to iOS for routing

The two twitch.tv rows above are Twitch's own web pages: when you approve a sign-in in the app or use the video player, Limerino loads www.twitch.tv/activate (which routes through www.twitch.tv/login when you need to sign in there), player.twitch.tv, and — when the theater is playing a clip — clips.twitch.tv, each inside a secure web view (WKWebView). For a follow, an unfollow or a watch-bonus claim it loads www.twitch.tv/popout/<name>/viewercard/<name> the same way, beneath its own screen and for that one request (see Follow, unfollow and the watch bonus). Those pages talk to Twitch's servers — including Twitch's video-delivery CDNs (hosts under ttvnw.net) — the same way twitch.tv does in a browser. If you sign in to Twitch with Apple, Amazon, or Google, Twitch's own login page hands off to that provider's sign-in page inside the same web view: you enter those credentials on the provider's page, and Limerino never sees them. Limerino adds no destinations of its own there — there is no address bar and nowhere to type one.

Connecting a 7TV account uses that same secure web view and that same Twitch web session, for Twitch's own authorization page — which is why approving is usually a single tap, and why a cold session routes through the same Twitch login journey described above. The 7TV address that ends the grant is read out of the navigation and never loaded, and Limerino runs no script on the pages of that grant.

Children's privacy and age rating

Limerino does not knowingly collect any data from anyone, including children under 13. Chat is live, third-party user-generated content from Twitch and can include mature language and links. Those links open in the system Safari view, where Screen Time web restrictions apply — except Twitch clip and video links, which open in Limerino's own Twitch player unless you turn that off in Settings → Video, and 7TV emote page links, which open a card inside Limerino while 7TV emotes & name colors is on (it is on by default) — turn that off and they are ordinary links again. That card shows one emote someone else uploaded to 7TV, and Limerino draws nothing 7TV marks mature or has deleted: those links open in the Safari view instead. Limerino provides reporting, blocking, and word filters, and Twitch moderates the content it hosts. If you link a 7TV account, the emote directory it opens shows artwork other people uploaded to 7TV: Limerino asks 7TV to leave out anything marked mature, drops anything that arrives marked anyway, and gives every result a report control, which both hands off to 7TV's own page and offers to hide that emote on this device. The current rating is the one shown on the app's App Store page.

Changes to this policy

If this policy changes, the new version replaces this one in-app on the next release. The release notes will call out the change.

Contact

Questions, requests, or copies of your data:

Email: hello@meipath.com
X (Twitter): @realmizeguy