# Mite: in-app feedback and release notes for Expo and React Native

Mite is in-app feedback and release notes for Expo and React Native apps.
Collect bug reports with full device context and feature requests from inside
your app, then publish release notes in the same place. Built for indie
developers and small teams who do not want a monitoring suite.

## What Mite does

- Collect user-reported bugs with app context
- Track bug status and priority
- Collect and prioritize feature requests
- Publish release notes and changelogs
- React Native and Expo SDK integration

## Setup to first bug report

1. Create your app and generate an API key. One project per app. Keys are scoped to it, rotatable, and safe to ship in a client build.
2. Install the SDK and wrap your root layout. One provider, one prop. No native config and no custom dev client, so it runs in Expo Go.
3. Reports arrive with the context already attached. Device, OS, build number, locale, and a screenshot, so you stop asking which version they were on.
4. Publish the release note from the report. The reporter sees their bug closed, everyone else sees the changelog on next launch.

## Questions

### Is Mite a full crash analytics platform?

No. Mite collects in-app feedback and publishes release notes for Expo and React Native apps. It records what a user chose to report, not what the runtime did, so pair it with Sentry or Bugsnag if you need crash capture too.

### Who is Mite for?

Indie developers and small teams building mobile apps with Expo or React Native.

### How long does setup take?

If your app is already running, you can create an app, generate a key, install the SDK, and send your first report in a few minutes.

### Why use Mite instead of a bigger platform?

Bigger platforms bundle crash capture, session replay, and performance monitoring, and they price for teams with a tooling budget. If all you want is feedback and release notes, you pay for the rest anyway. Mite covers that one job at a price a pre-revenue app can carry.

## Start

- [Create an account](https://usemite.com/sign-up): free to start
- [Developer docs](https://usemite.com/docs): SDK, REST API, webhooks
- [Pricing](https://usemite.com/pricing)

---

Canonical HTML: https://usemite.com/
Site index for agents: https://usemite.com/llms.txt
API description: https://usemite.com/openapi.json


# Mite developer docs: SDK, REST API, and webhooks

Mite is in-app feedback and release notes for Expo and React Native apps. Your
app sends bug reports, feature requests, and user identities to the Mite API;
you triage them in the Mite dashboard and publish release notes back to the
same app.

This page is the developer index: SDK, REST API, authentication, errors, rate
limits, webhooks, and the machine-readable files that describe all of it.

## Quickstart

1. Create an app in the [Mite dashboard](https://usemite.com/apps) and generate
   an API key under **Settings → Keys**.
2. Install the SDK in your Expo or React Native app.
3. Submit your first bug report.

```bash
npm install @usemite/mite-sdk
```

```tsx
import { Mite, MiteProvider, useBugReport } from '@usemite/mite-sdk'

const mite = new Mite({ apiKey: 'mite_ak_...' })
mite.init()

// Wrap your app once:
<MiteProvider miteInstance={mite}>{/* Your app */}</MiteProvider>

// Then submit bugs from anywhere:
const { submitBugReport } = useBugReport()
await submitBugReport({
  title: 'Something broke',
  description: 'What the user saw',
})
```

## SDK

The React Native and Expo SDK is published as
[`@usemite/mite-sdk`](https://github.com/usemite/mite-sdk). It wraps every
endpoint below, collects device and app context, and retries safely. Use it
unless you have a reason to call the API directly.

## Authentication

Every endpoint except `/api/v1/health` needs a Mite API key, sent as a bearer
token:

```
Authorization: Bearer mite_ak_...
```

Mite API keys are publishable, SDK-style tokens, like a Sentry DSN or a PostHog
project key. They ship inside your mobile binary and anyone can extract them
from a shipped APK or IPA, so **they are not secrets**. Mite handles abuse with
per-key rate limits and instant revocation instead of secrecy. Never use a Mite
key as a substitute for your own user authentication.

Each key carries scopes:

| Scope   | Grants                                                  |
| ------- | ------------------------------------------------------- |
| `read`  | List releases, announcements, feature requests          |
| `write` | Submit bug reports, feature requests, votes, identities |

A request with the wrong scope is refused with `403`.

## Base URL

```
https://intent-okapi-412.convex.site
```

## API endpoints

| Method | Path                             | Scope   | Purpose                                   |
| ------ | -------------------------------- | ------- | ----------------------------------------- |
| `GET`  | `/api/v1/health`                 | none    | Liveness probe                            |
| `POST` | `/api/v1/bug-reports`            | `write` | Submit a bug report                       |
| `POST` | `/api/v1/upload-url`             | `write` | Create a single-use attachment upload URL |
| `POST` | `/api/v1/identify`               | `write` | Create or update an end-user profile      |
| `GET`  | `/api/v1/releases`               | `read`  | List published releases                   |
| `GET`  | `/api/v1/announcements`          | `read`  | List active announcements                 |
| `GET`  | `/api/v1/feature-requests`       | `read`  | List feature requests                     |
| `POST` | `/api/v1/feature-requests`       | `write` | Submit a feature request                  |
| `POST` | `/api/v1/feature-requests/vote`  | `write` | Toggle a vote                             |
| `GET`  | `/api/v1/feature-requests/votes` | `read`  | List one voter's votes                    |
| `GET`  | `/getImage`                      | `read`  | Fetch a stored attachment                 |

Every path also answers `OPTIONS` for CORS preflight.

The full request and response schema for each endpoint is published as OpenAPI
3.1 at [usemite.com/openapi.json](https://usemite.com/openapi.json).

### Submit a bug report

```bash
curl -X POST https://intent-okapi-412.convex.site/api/v1/bug-reports \
  -H "Authorization: Bearer mite_ak_..." \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Crash when opening the Profile tab",
    "description": "The app closes immediately after tapping Profile.",
    "app_version": "1.4.2",
    "device_info": { "model": "iPhone 15", "os": "iOS 18.2" }
  }'
```

```json
{ "id": "j57...", "status": "NEEDS_TRIAGE" }
```

## Errors

Every failure returns JSON, never HTML. Branch on `code`, not on `error`.

```json
{
  "error": "API key is missing the required 'write' scope",
  "code": "forbidden",
  "hint": "Create a key with the write scope in Settings → Keys, or use an existing key that has it."
}
```

| Status | `code`                   | Meaning                                        |
| ------ | ------------------------ | ---------------------------------------------- |
| `400`  | `invalid_request`        | Malformed JSON, or a field failed validation   |
| `401`  | `unauthorized`           | Missing, malformed, or unknown API key         |
| `402`  | `REPORT_QUOTA_EXCEEDED`  | The plan's monthly report allowance is used up |
| `402`  | `STORAGE_QUOTA_EXCEEDED` | The plan's attachment storage is used up       |
| `403`  | `forbidden`              | The key lacks the scope the endpoint needs     |
| `404`  | `not_found`              | No such resource for this application          |
| `413`  | `payload_too_large`      | The request body is larger than 256 KB         |
| `429`  | `rate_limited`           | Per-key rate limit exceeded                    |
| `500`  | `internal_error`         | Unexpected server error                        |

A quota refusal is `402`, never `429`. A `429` tells a client to retry; a
monthly quota cannot improve by retrying, only by changing plan. Quota
responses carry a `quota` object with `limit`, `used`, and `resets_at`.

## Rate limits

Limits are per API key, as a token bucket refilled over one minute. They are
scoped to the key rather than to the application, so one misbehaving key cannot
exhaust the budget of a sibling key on the same app.

| Endpoint                          | Policy                    | Requests per minute |
| --------------------------------- | ------------------------- | ------------------- |
| `/api/v1/bug-reports`             | `bug-reports`             | 60                  |
| `/api/v1/upload-url`              | `upload-url`              | 30                  |
| `/api/v1/identify`                | `identify`                | 120                 |
| `/api/v1/releases`                | `releases`                | 120                 |
| `/api/v1/announcements`           | `announcements`           | 120                 |
| `/api/v1/feature-requests` (GET)  | `feature-requests-list`   | 120                 |
| `/api/v1/feature-requests` (POST) | `feature-requests-create` | 30                  |
| `/api/v1/feature-requests/vote`   | `feature-requests-vote`   | 60                  |
| `/api/v1/feature-requests/votes`  | `feature-requests-votes`  | 120                 |
| `/getImage`                       | `images`                  | 300                 |

`/api/v1/health` is unauthenticated and unmetered.

### Rate limit headers

Every metered response carries your remaining quota, so you can throttle before
you are refused rather than discovering the limit by hitting it. The fields
follow [the IETF RateLimit header fields draft](https://datatracker.ietf.org/doc/draft-ietf-httpapi-ratelimit-headers/).

```
RateLimit-Policy: "releases";q=120;w=60
RateLimit: "releases";r=118;t=1
RateLimit-Limit: 120
RateLimit-Remaining: 118
RateLimit-Reset: 1
```

| Field                 | Meaning                                                                  |
| --------------------- | ------------------------------------------------------------------------ |
| `RateLimit-Policy`    | The quota in force: `q` requests per `w` seconds                         |
| `RateLimit`           | What is left for you: `r` requests, `t` seconds until the quota is whole |
| `RateLimit-Limit`     | Superseded plain-integer form of `q`                                     |
| `RateLimit-Remaining` | Superseded plain-integer form of `r`                                     |
| `RateLimit-Reset`     | Superseded plain-integer form of `t`                                     |

The three plain-integer fields are from an earlier draft and are no longer part
of the specification. Mite still sends them because most deployed HTTP clients
read them; prefer `RateLimit` and `RateLimit-Policy` in new code.

All of them are named in `Access-Control-Expose-Headers`, so a browser can read
them cross-origin.

A refused request returns `429` with `Retry-After` in seconds, alongside
`RateLimit` reporting `r=0`. When both are present, `Retry-After` is
authoritative.

```
HTTP/1.1 429 Too Many Requests
Retry-After: 1
RateLimit-Policy: "bug-reports";q=60;w=60
RateLimit: "bug-reports";r=0;t=60
```

### Rate limits on usemite.com

The machine-readable documents on usemite.com carry `RateLimit-Policy` and are
metered per client at 600 requests per minute. Those documents are
`/openapi.json`, `/api/v1`, `/.well-known/api-catalog`, `/agents.md`,
`/llms-full.txt`, and the JSON errors under `/api/`.

Those responses carry no live `RateLimit` field. They are publicly cacheable,
and a shared cache would otherwise hand one client's remaining quota to the
next. A refusal is `no-store`, so it carries the full set.

## Webhooks

Mite posts outgoing notifications to Discord and Slack. Add an incoming webhook
URL under **Settings → Webhooks** in the dashboard and choose which events fire:

- a new bug report arrives
- a bug report changes status
- a new feature request arrives

Discord URLs must start with `https://discord.com/api/webhooks/` and Slack URLs
with `https://hooks.slack.com/services/`. Mite does not accept inbound webhooks.

## Machine-readable resources

| Resource                                                         | What it is                                       |
| ---------------------------------------------------------------- | ------------------------------------------------ |
| [/openapi.json](https://usemite.com/openapi.json)                       | OpenAPI 3.1 description of the Mite API          |
| [/api/v1](https://usemite.com/api/v1)                                   | Mite API discovery document                      |
| [/.well-known/api-catalog](https://usemite.com/.well-known/api-catalog) | Mite API catalog, as an RFC 9727 linkset         |
| [/agents.md](https://usemite.com/agents.md)                             | When to use Mite, and how to make the first call |
| [/llms.txt](https://usemite.com/llms.txt)                               | Index of Mite's pages for agents                 |
| [/llms-full.txt](https://usemite.com/llms-full.txt)                     | Every Mite page as one Markdown document         |
| [/sitemap.xml](https://usemite.com/sitemap.xml)                         | Every public page                                |
| [/docs.md](https://usemite.com/docs.md)                                 | This page as Markdown                            |

Every public page also answers `Accept: text/markdown` with a Markdown
rendition of itself, and advertises it with a `Link: rel="alternate"` header.

## Support

Open an issue on [github.com/usemite/mite-sdk](https://github.com/usemite/mite-sdk)
for SDK problems, or use the in-app feedback widget in the Mite dashboard.

---

Canonical HTML: https://usemite.com/docs
Site index for agents: https://usemite.com/llms.txt
API description: https://usemite.com/openapi.json


# Mite pricing

Mite prices in-app feedback and release notes for indie mobile developers.
Plans and current prices are served live on
[usemite.com/pricing](https://usemite.com/pricing). This page does not restate them, so
it can never quote a stale figure.

## How plans differ

A plan sets three quotas and a feature set.

- **Apps.** How many applications you can create.
- **Reports.** How many bug reports the account accepts per billing period.
- **Attachment storage.** How many bytes of screenshots and files you can keep.

Features gated by plan:

- Bug reporting
- Release notes
- Feature request board
- Webhooks
- Linear integration
- GitHub integration

## What happens at a limit

Reaching a report or storage quota returns HTTP 402 from the API with a
`code` of `REPORT_QUOTA_EXCEEDED` or `STORAGE_QUOTA_EXCEEDED` and a
`quota` object carrying `limit`, `used`, and `resets_at`. It is
deliberately not a 429: retrying cannot clear a monthly quota, only a plan
change can. See the [developer docs](https://usemite.com/docs) for the full error contract.

## Start

- [See live pricing](https://usemite.com/pricing)
- [Create an account](https://usemite.com/sign-up)

---

Canonical HTML: https://usemite.com/pricing
Site index for agents: https://usemite.com/llms.txt
API description: https://usemite.com/openapi.json


# Mite vs Instabug

Both tools collect bug reports from inside your app. They are built for different people, and the honest answer is that one of them is probably wrong for you.

## Choose Instabug instead if

- You need automatic crash and ANR capture, not only the reports a user chooses to send.
- You ship native iOS, Android, or Flutter builds as well as React Native.
- You need session replay to see what the reporter did before they filed.
- You want real-user performance monitoring alongside the feedback.
- You run in-app surveys or NPS and want them in the same SDK.
- Your procurement needs SSO, a signed security review, or a support commitment.

Check the claims below against [Instabug's own pricing and features](https://www.instabug.com/pricing).

## The short answer

Instabug is a mobile observability platform. It covers bug reporting, crash
reporting, performance monitoring, session replay, and in-app surveys, and it is
sold to product and engineering teams who have a budget line for tooling.

Mite does one narrower job. It collects bug reports and feature requests from
the people using your app, and it publishes your release notes back to them. It
is built for a solo developer or a small team shipping an Expo or React Native
app, at a price that makes sense before the app earns money.

If you need crash reporting and performance monitoring, Instabug is the better
product and you should buy it. If you need to hear from your users and you are
paying for the tool yourself, keep reading.

## Side by side

|                                    | Mite                            | Instabug                                 |
| ---------------------------------- | ------------------------------- | ---------------------------------------- |
| User-submitted bug reports         | Yes                             | Yes                                      |
| Device, version, and build context | Yes                             | Yes                                      |
| Screenshots and attachments        | Yes                             | Yes                                      |
| Feature requests and voting        | Yes                             | Limited                                  |
| Public roadmap                     | Yes                             | No                                       |
| Release notes and changelog        | Yes                             | No                                       |
| Automatic crash reporting          | No                              | Yes                                      |
| Performance monitoring             | No                              | Yes                                      |
| Session replay                     | No                              | Yes                                      |
| In-app surveys                     | No                              | Yes                                      |
| Platforms                          | React Native and Expo           | iOS, Android, React Native, Flutter, web |
| Built for                          | Solo developers and small teams | Funded product teams                     |

## Where Mite is the better fit

**You are the whole team.** Mite assumes one person triages everything. There are
no seats to buy, no roles to configure, and no workspace hierarchy to set up
before you can read your first report.

**You want the feedback loop, not the telemetry.** A crash tells you the app
broke. A bug report tells you what the person was trying to do. Mite is built
around the second one, and it closes the loop: a reporter can see the release
note when you ship the fix.

**Expo is a first-class target.** The SDK is written for React Native and Expo,
so it captures the runtime version, the release channel, and the EAS update ID
along with the report. There is no native build step to fight.

**The price fits a pre-revenue app.** Mite has a free tier that is meant to be
used, not to expire.

## Using both

These tools do not exclude each other, and many small teams run both. A common
split is Instabug or a crash reporter for the automatic signals, and Mite for
the things a user chooses to tell you. Mite does not intercept crashes, so the
two SDKs do not fight over the same handlers.

## Moving from Instabug to Mite

The migration is small, because the surface is small. Install the Mite SDK,
point it at your app key, and remove the Instabug bug-reporting widget. Your
existing Instabug reports do not transfer, because Mite has no importer today.
Most teams leave the old history where it is and start fresh. A bug report loses
its value once the release it describes has shipped.

_Last reviewed August 24, 2026. Instabug may have changed its product or pricing since then._

---

Canonical HTML: https://usemite.com/alternatives/instabug
Site index for agents: https://usemite.com/llms.txt
API description: https://usemite.com/openapi.json


# Mite vs Shake

Both tools turn a shake of the device into a bug report with the device state attached. The difference is what happens to that report next, and who the tool is priced for.

## Choose Shake instead if

- You ship to platforms Mite does not cover: native iOS, Android, Flutter, or web.
- You need automatic crash capture alongside user-submitted reports.
- You want a bug-reporting product with a longer track record than Mite has.
- Your procurement needs SSO, a signed security review, or a support commitment.

Check the claims below against [Shake's own pricing and features](https://www.shakebugs.com/pricing/).

## The short answer

Shake is a bug-reporting SDK. A user shakes the device, a report form opens, and
you receive the report with the device state attached. It supports a wide set of
platforms and it is sold to development teams.

Mite covers the same shake-to-report moment, then continues past it. The same
tool collects feature requests, ranks them by votes, shows a public roadmap, and
publishes the release notes that tell your users what you fixed.

Shake is the more established bug-reporting tool with broader platform support.
Mite is narrower on platforms and wider on the feedback loop, and it is priced
for one person.

## Side by side

|                                    | Mite                            | Shake                                    |
| ---------------------------------- | ------------------------------- | ---------------------------------------- |
| Shake-to-report                    | Yes                             | Yes                                      |
| Device, version, and build context | Yes                             | Yes                                      |
| Screenshots and attachments        | Yes                             | Yes                                      |
| Screen navigation trail            | Yes                             | Yes                                      |
| Feature requests and voting        | Yes                             | No                                       |
| Public roadmap                     | Yes                             | No                                       |
| Release notes and changelog        | Yes                             | No                                       |
| Automatic crash reporting          | No                              | Yes                                      |
| Platforms                          | React Native and Expo           | iOS, Android, React Native, Flutter, web |
| Built for                          | Solo developers and small teams | Development teams                        |

## Where Mite is the better fit

**You want one tool, not three.** With Shake you still need a board for feature
requests and something else again for release notes. Mite is all three, and they
share one user record, so you can see that the person filing this bug also
requested that feature.

**Expo is a first-class target.** Mite captures the runtime version, the release
channel, and the EAS update ID with every report. There is no native module to
configure and no prebuild step to manage.

**You are paying for it yourself.** Mite's free tier is designed for an app that
has not started earning yet.

## Moving from Shake to Mite

Swap the SDK and remove the Shake initializer. Mite has no importer for existing
Shake reports today, so plan to leave that history where it is. An open bug
report matters only until the release that fixes it ships.

_Last reviewed August 24, 2026. Shake may have changed its product or pricing since then._

---

Canonical HTML: https://usemite.com/alternatives/shake
Site index for agents: https://usemite.com/llms.txt
API description: https://usemite.com/openapi.json


# Mite privacy policy

_Last updated July 31, 2026._

Mite is operated by Henry PL, LLC, a Delaware limited liability company ("Mite", "we", "us", or "our"). This policy explains what personal information we collect, why we collect it, and what control you have over it.

If you have any question about anything below, email us at [hello@usemite.com](mailto:hello@usemite.com).

## The short version

- We collect the minimum we need to run an in-app feedback service.
- We do not sell your personal information, and we never have.
- We do not use your data, or your users' data, to train machine learning models.
- We do not run advertising or share data with ad networks.
- You can export or delete your data at any time by emailing us.

## Two kinds of data, two different roles

Mite handles two categories of personal information, and our responsibilities differ for each.

**Customer data** is information about you, the developer or team who signs up for Mite. We decide how this information is used, which makes us the data controller for it.

**End user data** is information about the people who use _your_ mobile app and submit bug reports through the Mite SDK. You decide what your app sends to us and how long it is kept. We hold and process that information on your behalf, which makes us a data processor and you the controller. If you are an end user of an app that uses Mite and you want your data removed, contact the developer of that app directly. They control it, and we act on their instruction.

## What we collect

### Information you give us

When you create an account, authentication is handled by Clerk, and we store your name, email address, and a Clerk user identifier. If you create or join an organization, we store the organization name and its membership list. If you subscribe to a paid plan, we store your plan name and its feature entitlements. We never see or store your full card number; payments are processed by Stripe through Clerk Billing.

When you create an application in Mite, we store its name, slug, and any icon you upload.

### Information sent by the Mite SDK

When an end user submits a bug report from an app that has integrated Mite, we may receive and store:

- The report itself: title, description, steps to reproduce, expected and actual behavior
- Contact details, if your app supplies them or the reporter enters them: name and email address
- A user identifier or an anonymous identifier that you assign
- Device and environment information: device model, operating system version, app version, runtime version, release channel, and EAS update identifier
- The IP address last seen for that end user
- A navigation trail of screens visited before the report, with timestamps
- Any screenshots or files attached to the report
- Aggregate counts such as session count, error count, and number of reports submitted

**You control what reaches us.** Fields such as email, name, and user identifier are optional and are only stored if your integration provides them. Screenshots capture whatever was on screen at the moment of capture, so please make sure your integration does not capture sensitive information, and instruct your users not to include it in free-text fields.

### Information collected automatically on our website

We use PostHog for product analytics and error monitoring, Vercel Analytics for aggregate traffic measurement, and the Reddit Pixel for advertising attribution and conversion measurement. These record pages visited, approximate location derived from IP address, browser and device type, and interactions within the app. If you are signed in and have consented to advertising measurement, we also send your email address and Mite user identifier to Reddit as match keys. We use this information to understand which features are used, diagnose failures, and measure the effectiveness of our advertising.

## How we use information

We use personal information to operate and maintain the service, authenticate you, deliver bug reports and notifications, process payments and enforce plan limits, respond to support requests, diagnose problems, detect abuse and secure the service, and comply with legal obligations.

If you are in the European Economic Area or the United Kingdom, our legal bases are: performance of a contract for operating the service and processing payments; legitimate interests for security, abuse prevention, and product analytics; consent where required, such as for non-essential cookies; and legal obligation where the law requires retention.

## Who we share it with

We share personal information only with service providers who help us run Mite, and only to the extent needed for them to do that work. Our sub-processors are:

| Provider | Purpose                                            |
| -------- | -------------------------------------------------- |
| Clerk    | Authentication, user accounts, and billing         |
| Convex   | Database and file storage                          |
| Vercel   | Application hosting and traffic analytics          |
| PostHog  | Product analytics and error monitoring             |
| Reddit   | Advertising attribution and conversion measurement |
| Resend   | Transactional and notification email               |
| Svix     | Outbound webhook delivery                          |
| Stripe   | Payment processing, via Clerk Billing              |

If you connect an optional integration, we send the data required for it to work to that provider. GitHub and Linear receive bug report content when you create an issue from a report. If you configure outbound webhooks, bug report data is delivered to the endpoint you specify, and you are responsible for that endpoint.

We may also disclose information if required by law, valid legal process, or to protect the rights, safety, and property of Mite, our customers, or the public. If Mite is involved in a merger, acquisition, or sale of assets, personal information may be transferred as part of that transaction; we will give notice before your information becomes subject to a different privacy policy.

We do not sell personal information.

## Cookies

We use cookies that are strictly necessary to keep you signed in and to protect your session; these are set by Clerk and cannot be turned off without breaking the service. We also store your light or dark theme preference locally in your browser.

PostHog, Vercel Analytics, and the Reddit Pixel set analytics or advertising cookies or use similar local storage to measure product usage and advertising performance. Where the law requires prior consent, including in the EEA, the UK, and Switzerland, these tools are switched off until you accept them, and we ask before setting them. You can decline without losing any functionality, and you can change your mind by clearing this site's data in your browser. You can also block cookies in your browser settings, though the service will not work correctly without the essential ones.

Declining these tools stops all tracking in your browser. Separately, when you create an account, our servers record that a signup occurred, together with your Mite user identifier and the sign-in method you used. This record sets no cookie and reads nothing from your browser. We rely on legitimate interests for it, because we need an accurate count of accounts created to operate and measure the service.

## How long we keep it

We keep your account information for as long as your account is active. Bug reports, end user profiles, and attachments are kept until you delete them, or until you delete the application they belong to; deleting an application immediately and permanently erases its bug reports, comments, attachments, end user profiles, releases, and API keys, including the stored files themselves.

When you close your account, your applications and everything in them are marked for deletion straight away. They stop being served publicly, stop accepting new bug reports from your SDK, and can no longer be accessed by anyone. They are permanently erased after a 30-day grace period, which exists so that an accidental account deletion can be reversed: if you email us within that window we can restore your account and its data. After the window closes the data is unrecoverable, including by us. We may retain records for longer only where we are required to for legal, tax, or accounting purposes. Backups are purged on a rolling basis.

## Security

We use HTTPS for all traffic, encrypt data at rest through our infrastructure providers, restrict internal access to what is necessary, and apply security headers including HSTS and a content security policy. API keys are scoped per application and can be revoked at any time.

No online service can promise perfect security. If we become aware of a breach affecting your personal information, we will notify you and any relevant regulator as required by law.

## Your rights

Depending on where you live, you may have the right to access the personal information we hold about you, correct it if it is inaccurate, delete it, export it in a portable format, object to or restrict certain processing, and withdraw consent where processing is based on consent. California residents additionally have the right not to receive discriminatory treatment for exercising these rights.

To exercise any of these, email [hello@usemite.com](mailto:hello@usemite.com). We will respond within 30 days. We may need to verify your identity before acting. You also have the right to complain to your local data protection authority.

## International transfers

Mite is operated from the United States, and our providers process data in the United States and other countries. If you access Mite from outside the United States, your information is transferred to and processed in the United States. Where required, we rely on Standard Contractual Clauses or an equivalent transfer mechanism through our providers.

## Children

Mite is a tool for software developers and is not directed at children. We do not knowingly collect personal information from anyone under 16. If you believe a child has provided us with personal information, email us and we will delete it.

## Changes to this policy

We may update this policy as the service changes. If we make a material change, we will update the date at the top of this page and notify account holders by email or in the app before the change takes effect. Continuing to use Mite after a change means you accept the updated policy.

## Contact

Questions, requests, or complaints about this policy can be sent to [hello@usemite.com](mailto:hello@usemite.com).

---

Canonical HTML: https://usemite.com/privacy
Site index for agents: https://usemite.com/llms.txt
API description: https://usemite.com/openapi.json


# Mite terms of service

_Last updated July 31, 2026._

These terms are a binding agreement between you and Henry PL, LLC, a Delaware limited liability company ("Mite", "we", "us", or "our"), covering your use of the Mite website, application, SDK, and API (together, the "Service").

By creating an account or using the Service, you agree to these terms. If you are agreeing on behalf of a company or other organization, you confirm that you have the authority to bind it, and "you" refers to that organization.

## Who can use Mite

You must be at least 16 years old and capable of forming a binding contract. If you are barred from using services like this under the laws of your country or the United States, you may not use the Service.

## Your account

You are responsible for everything that happens under your account, for keeping your login credentials secure, and for the accuracy of the information you give us. Authentication is handled by Clerk, and their terms apply to the authentication layer. Tell us promptly at [hello@usemite.com](mailto:hello@usemite.com) if you suspect unauthorized access.

API keys issued to your applications are secrets. Treat them as such: do not commit them to public repositories or ship them where they can be extracted and abused. You are responsible for activity carried out with your keys, and you can revoke and reissue them at any time from your application settings.

## Plans and billing

Mite offers a free plan and paid plans. Paid plans are billed in advance on a recurring basis through Clerk Billing, with payments processed by Stripe. By subscribing you authorize us to charge your payment method on each renewal until you cancel.

Plans carry usage limits, which are described on our pricing page. We may enforce those limits by restricting access to features once a limit is reached.

You can cancel at any time from your subscription settings. Cancellation takes effect at the end of the current billing period, and you keep access until then. **Fees already paid are non-refundable except where required by law.** We may change our prices with at least 30 days' notice; changes take effect at your next renewal, and your continued use after that constitutes acceptance.

Fees are exclusive of taxes, and you are responsible for any taxes other than those based on our net income.

## Acceptable use

You agree not to:

- Use the Service to break the law or infringe anyone's rights
- Upload malware, or attempt to probe, scan, or breach our security or authentication
- Reverse engineer, decompile, or attempt to extract source code from the Service, except where that restriction is prohibited by law
- Resell or white-label the Service as your own competing in-app feedback product
- Use automated means to place unreasonable load on our infrastructure, or circumvent rate limits and plan limits
- Submit personal information you have no lawful basis to share with us
- Use the Service to store special categories of sensitive data, including health records, government identification numbers, or full payment card details

We may suspend or terminate accounts that violate these rules. Where practical we will warn you first, but we may act immediately where there is risk to the Service or to other customers.

## Your content

You keep ownership of everything you and your users put into Mite: bug reports, attachments, release notes, feature requests, and account information ("Your Content"). We claim no ownership over it.

You grant us a limited, non-exclusive, worldwide license to host, store, process, transmit, and display Your Content solely to operate and improve the Service for you, and to provide support. This license ends when you delete the content or close your account, apart from residual copies in backups that are purged on a rolling schedule.

We do not use Your Content to train machine learning models.

## Your responsibilities for end user data

The Mite SDK collects data from the people who use your app. As between you and us, **you are the controller of that data and we are your processor.** You are responsible for:

- Having a lawful basis to collect the data your app sends us
- Maintaining your own privacy policy that discloses your use of Mite
- Obtaining any consent required in your jurisdiction
- Configuring your integration so that it does not capture data you are not entitled to collect, including via screenshots
- Responding to your users' access and deletion requests

We process end user data on your instructions, as described in our [Privacy Policy](/privacy). If you need a signed data processing agreement, contact us.

## Service availability

We aim to keep Mite available and reliable, but we do not offer a formal uptime guarantee on any plan. We may modify, suspend, or discontinue features, and we will give reasonable notice of material changes that reduce core functionality. Scheduled maintenance may cause brief interruptions.

## Third-party services

Mite integrates with services we do not control, including GitHub, Linear, and any webhook endpoint you configure. Your use of those integrations is governed by their terms, and we are not responsible for their acts, omissions, availability, or handling of data once it leaves our systems at your instruction.

## Our intellectual property

The Service, including its software, design, and trademarks, belongs to Mite and its licensors. These terms grant you a limited, non-exclusive, non-transferable, revocable right to use the Service in line with this agreement, and nothing more.

If you send us feedback or suggestions, we may use them without restriction or obligation to you.

## Termination

You can stop using the Service and delete your account at any time. We may suspend or terminate your access if you materially breach these terms, if your account is used unlawfully, or if we are required to by law.

When your account ends, your right to use the Service stops immediately and we will delete your data as described in our Privacy Policy. Export anything you want to keep beforehand. Sections that by their nature should survive termination will survive it, including ownership, disclaimers, limitation of liability, indemnification, and governing law.

## Disclaimers

**The Service is provided "as is" and "as available", without warranties of any kind, whether express, implied, or statutory,** including implied warranties of merchantability, fitness for a particular purpose, title, and non-infringement.

We do not warrant that the Service will be uninterrupted, secure, or error-free, that defects will be corrected, or that data will never be lost. Mite is an in-app feedback tool, not a backup service or a system of record. Keep your own copies of anything you cannot afford to lose.

## Limitation of liability

**To the maximum extent permitted by law, Mite will not be liable for any indirect, incidental, special, consequential, exemplary, or punitive damages, or for lost profits, revenue, data, or goodwill,** even if we have been advised of the possibility of those damages.

**Our total aggregate liability arising out of or relating to these terms or the Service will not exceed the greater of (a) the amount you paid us in the 12 months before the event giving rise to the claim, or (b) one hundred US dollars ($100).**

Some jurisdictions do not allow certain limitations, so parts of this section may not apply to you. Nothing here limits liability for fraud, willful misconduct, or anything else that cannot be limited by law.

## Indemnification

You agree to indemnify and hold harmless Mite and its officers, members, and employees from any claim, demand, loss, or expense, including reasonable legal fees, arising out of your use of the Service, Your Content, your violation of these terms, or your violation of any law or third-party right, including the rights of your end users.

## Governing law and disputes

These terms are governed by the laws of the State of Delaware, without regard to its conflict of laws rules. You and Mite agree to the exclusive jurisdiction of the state and federal courts located in Delaware for any dispute that is not resolved informally.

Before filing anything, please email [hello@usemite.com](mailto:hello@usemite.com) and give us 30 days to try to resolve the matter with you directly. Most problems are faster to fix than to litigate.

## Changes to these terms

We may update these terms as the Service evolves. If a change is material, we will update the date at the top of this page and notify account holders by email or in the app before it takes effect. Continuing to use Mite after that means you accept the new terms. If you do not accept them, stop using the Service and cancel your account.

## General

These terms, together with our [Privacy Policy](/privacy), are the entire agreement between you and Mite regarding the Service. If any provision is found unenforceable, the rest remains in effect. Our failure to enforce a provision is not a waiver of it. You may not assign this agreement without our written consent; we may assign it in connection with a merger, acquisition, or sale of assets.

## Contact

Questions about these terms can be sent to [hello@usemite.com](mailto:hello@usemite.com).

---

Canonical HTML: https://usemite.com/terms
Site index for agents: https://usemite.com/llms.txt
API description: https://usemite.com/openapi.json