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 analytics, no advertising SDKs, and no trackers. It 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); 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); 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 — 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); 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); 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. While you are signed in, requests to Twitch carry your Twitch sign-in token, because that is how Twitch authenticates you; the third-party emote/badge providers receive neither a token nor any separate 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. The one exception is a 7TV account you link yourself: the requests that read your 7TV identity and make the emote and name-paint 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). 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, while mention alerts are on (see Mention alerts & Mention Vault), 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). 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 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).
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. They are owner-scoped, never shared between accounts, and never uploaded. Clear them in the app, 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).
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. That 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 (see Follow & subscription details on a user card).
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).
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).

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 once per established player session to Twitch's own token-check endpoint (id.twitch.tv), which is how the app verifies that the player's session belongs to the same Twitch account you signed into. 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.

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 <Documents>/Limerino/Logs/<channel>.jsonl. 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. 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 one exception: 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.

To remove: Uninstall the app — 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.

To remove: Whispers → Clear deletes them from the device, as does uninstalling the app. Signing out hides them and stops new ones, but keeps this account's saved whispers on the device for when you sign back in — use Clear 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. It is local-only and never uploaded.

To remove: Clear it from the Inbox to delete the saved entries, 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 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. 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.
Notification preferences — your per-channel alert toggles, same-sender cooldown, batch window, quiet hours and time zone, and delivery mode (real-time or summary), so the server knows which pushes to send and when.

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. Turn mention alerts off or sign out and that push token is removed right away. 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 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.
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.

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, 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.

Discord account linking (only if you link one)

If you tap Link Discord on your profile, 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.

Removing it: Unlink on your profile 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.

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 your own account owns and which one 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 (clearing one 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.

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. 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. Signing out of Limerino, or switching to a different Twitch account, does the same thing on its own: a 7TV link belongs to the one Twitch account that made it. 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.

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 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: OpenAI 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 OpenAI and stay in Limerino's private backend.

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 OpenAI 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.

Follow & subscription details on a user card (`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. Twitch's own API answers those questions only for a channel's own broadcaster or moderators, so the answer 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.

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) and the Inbox → Clear (saved mentions / highlights).
Sign out (Settings → Account → Sign out) asks Twitch to revoke the access token (best effort — it is not retried if that network call fails), removes that account's entry from the device Keychain, clears the video player's Twitch web session, disconnects a linked 7TV account — ending that session on 7TV and deleting its stored token (see 7TV account linking) — and hides the signed-in data from view. It does not delete that account's saved whispers or Inbox — those rows stay owner-scoped on the device and reappear if you sign back into the same account. Use the in-app Clear actions above, or uninstall, to delete them.
Uninstall the app removes Limerino's entire on-device sandbox: 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 sign out first if you want to be certain the stored tokens are gone — the Twitch ones, and a linked 7TV one. There is no single in-app "erase everything" button today; 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, and notification preferences that using mention alerts adds, and the stored link that linking a Discord account adds (which Unlink on your profile 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). 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.

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, no telemetry, no crash-reporter pinging an outside 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 one background data flow is 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). 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); and — 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. 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). 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)	After the app validates your signed-in Twitch account	TLS IRC frames for channels you open; chat you send when the validated permissions allow it
`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, chat settings, and badges
`id.twitch.tv` (Twitch OAuth)	During sign-in, token refresh, periodic token validation, the player-session account check, and — if you connect a 7TV account — the authorization page for that grant	OAuth handshake and validation; the player 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	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)
`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	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
`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 for anyone whose name Limerino draws in chat — 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 or the name-paint 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 cosmetic 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. This is what lets your OWN 7TV paint and badge appear, which the `events.7tv.io` socket can never deliver. What comes BACK is only the paint and badge each account currently wears (their definitions and artwork addresses); Limerino asks for nothing else about those accounts — deliberately not their linked Discord or Kick account ids, which this route would otherwise return — keeps what it gets 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 your own account owns and which one 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 (clearing one sends an explicit empty value, not an id), any name, tag, emote-slot count or active-set choice you made, and the 7TV account id of the channel when you create a set or choose which of its sets is active (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.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
`static-cdn.jtvnw.net` (Twitch)	When chat renders Twitch emotes / badges	Emote / badge id → 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 or draws an image name paint, when the emote-set screens or the emote directory render artwork, and when the name-paint screen loads previews of the image paints your account owns	Emote id or paint 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
`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
`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 → how long they have followed it and their public subscription standing there. 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. Kept in memory for the session, 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)	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)
`api.limerino.com` (mention alerts — alert delivery)	While mention alerts are on	This device's APNs push token, so a matched mention 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, or you import settings that carry blocked users	Your followed-channel list (names only), notification preferences (per-channel toggles, cooldowns, quiet hours + time zone, delivery mode), and your muted-sender list — the Twitch ID or login of each user whose mentions you have muted, blocking anyone in the app included
`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` (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. OpenAI receives the description, basic metadata, and salted safety identifier to triage the request automatically; diagnostics never go to OpenAI. 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	Twitch's own activation / login / player / clip 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
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). 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