# Configuration
Source: https://docs.coreply.app/configuration/settings

Reference for Coreply settings that are independent of your AI provider.

Open Coreply. The main screen contains **Select Apps** and **Coreply Settings**. Provider-specific setup lives under [Providers](/providers/overview).

## Select Apps

Choose the apps where Coreply is active. Coreply only runs inside the apps you enable here.

## Suggestion mode

Controls where suggestions appear on screen.

* `overlay` shows the floating bubble below the text field.
* `inline` shows ghost text inside the text field.
* `both` shows both at the same time.

## Debounce (ms)

How long Coreply waits after you stop typing before it requests a suggestion. Range: `0` to `1000` ms.

* Lower values feel faster, but send more requests.
* Higher values reduce request volume, but add delay before suggestions appear.

## Enable Regex Filter

When enabled, Coreply only requests a suggestion when your current typing matches the regex pattern below.

## Typing Regex Pattern

The regex used by **Enable Regex Filter**. The default pattern, `^.*[\s.!?,;:]$`, triggers suggestions after a word ending in whitespace or punctuation.

## Show errors

When enabled, API and network errors are shown in the on-screen overlay while you type.


# FAQ
Source: https://docs.coreply.app/faq

Answers to frequently asked questions about Coreply.

<AccordionGroup>
  <Accordion title="Is Coreply free?">
    Yes. The Coreply app is free and open source under the [AGPL-3.0 license](https://github.com/coreply/coreply/blob/main/LICENSE).

    To use Coreply, you need one of the following:

    * **Your own AI API key** — Many providers offer free tiers (Google AI Studio and Groq are good starting points).
    * **Coreply Cloud** — A hosted option (with free and paid plans) available at [coreply.up.nadles.com](https://coreply.up.nadles.com/). Sign up and paste your access key into the app.
  </Accordion>

  <Accordion title="Does Coreply collect my messages?">
    When you use your own API key, all traffic goes directly from your device to the AI provider you configured. No data passes through any Coreply servers.

    If you use **Coreply Cloud**, traffic is routed through hosted servers to reach the AI provider.

    As of April 2026, Coreply does not store, log, or sell your message content.
  </Accordion>

  <Accordion title="Can I use my own AI server?">
    Yes. Choose **OpenAI Compatible** under **API Provider**. Then configure the following fields:

    * **Base URL** — The endpoint URL of your server (for example, `http://localhost:11434/v1`)
    * **API Key** — Your API key, or any non-empty string if your server doesn't require one
    * **Model** — The exact model identifier your server expects

    This lets you run Coreply against self-hosted models, local inference servers, or any compatible third-party service.
  </Accordion>

  <Accordion title="Why does Coreply need accessibility permission?">
    Coreply uses Android's accessibility service to read the text you are typing, capture other relevant on-screen text in selected apps, and display suggestion overlays. This is the only way an app can integrate with third-party apps on Android without those apps being modified to support it.
  </Accordion>

  <Accordion title="Can I add support for a new app?">
    Yes. Coreply is open source and contributions are welcome. Visit the [GitHub repository](https://github.com/coreply/coreply) and open a pull request.

    Please reach out before making significant contributions — the project is in active development and breaking changes may occur.
  </Accordion>

  <Accordion title="What is the debounce delay?">
    The debounce delay controls how long Coreply waits after you stop typing before it sends a request to the AI provider for a suggestion.

    * **Lower delay** — Suggestions appear faster, but more API requests are made (which may exhaust free-tier rate limits more quickly).
    * **Higher delay** — Fewer API requests are made, but suggestions take longer to appear after you pause.

    You can adjust the debounce delay in **Coreply Settings**. The right value depends on your typing speed and the latency of your chosen provider.
  </Accordion>
</AccordionGroup>


# Installation
Source: https://docs.coreply.app/installation

Install Coreply on your Android device by downloading the APK from GitHub Releases or using Obtainium.

<Steps>
  <Step title="Check requirements">
    Coreply requires **Android 8 or higher**. Android 13 or higher is recommended for the best experience.
  </Step>

  <Step title="Download the APK">
    Download the latest APK from the [Coreply releases page](https://github.com/coreply/coreply/releases).

    Alternatively, you can install and update Coreply through [Obtainium](https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://github.com/coreply/coreply), which tracks GitHub releases and notifies you when a new version is available.

    <Note>
      To verify the authenticity of the APK, check that the SHA-256 hash of the signing certificate matches:

      ```text theme={null}
      87:95:62:D0:13:BD:E2:44:8E:D9:B2:F3:78:F0:DB:96:02:BF:BB:CF:70:E8:65:A0:25:F4:D2:52:D0:EB:AA:94
      ```

      You can verify this in Android Studio using `apksigner verify --print-certs`, or through a tool like `apkinfo`.
    </Note>
  </Step>

  <Step title="Install the APK">
    Open the downloaded APK file on your device to begin installation. Proceed through the standard Android installation dialog.
  </Step>

  <Step title="Open the app and proceed to quick start">
    After installation completes, open Coreply from your app drawer and follow the [Quick Start](/quickstart) guide to configure your AI provider and enable the service.
  </Step>
</Steps>


# Introduction
Source: https://docs.coreply.app/introduction

Coreply is an open-source Android app that provides real-time AI-powered suggestions as you type inside supported apps.

Coreply uses Android's accessibility service to read relevant visible text on screen and send it to an AI provider of your choice. As you type, suggestions appear in a floating overlay — no switching apps, no copy-pasting.

<CardGroup>
  <Card title="Installation" icon="download" href="/installation">
    Download the APK and install Coreply on your Android device.
  </Card>

  <Card title="Quick start" icon="bolt" href="/quickstart">
    Get your first suggestion in under 5 minutes.
  </Card>

  <Card title="AI providers" icon="microchip" href="/providers/overview">
    Connect Coreply Cloud, OpenAI, Google, Groq, OpenRouter, xAI, Mistral,
    MiniMax, Azure, Vercel AI Gateway, or any OpenAI-compatible endpoint.
  </Card>

  <Card title="Supported apps" icon="mobile" href="/supported-apps">
    See the full list of explicitly supported apps.
  </Card>
</CardGroup>

## Key features

* **Real-time suggestions** — the overlay updates as you type, showing context-aware completions drawn from the current conversation.
* **20+ supported apps** — includes WhatsApp, WhatsApp Business, Telegram, Nekogram, Instagram, Signal, Discord, Hinge, Tinder, LINE, Snapchat, Facebook Messenger, Google Messages, Microsoft Teams, Mattermost, Viber, Heymandi, Beeper, ChatGPT, Perplexity, and Android notification replies.
* **Bring your own AI provider** — connect OpenAI, Google Gemini API, Google Vertex, Groq, OpenRouter, Azure OpenAI, xAI, Mistral, MiniMax, Vercel AI Gateway, or any OpenAI-compatible endpoint.
* **Coreply Cloud** — a hosted option that requires no API key setup. Sign up and paste a single access key.
* **No data collection** — when using your own provider, conversation data travels directly from your device to the inference API. Nothing passes through intermediate servers.
* **Open source** — licensed under the GNU AGPL v3.

## How it works

Coreply runs as an Android accessibility service. When you open a supported app and start typing, Coreply reads the relevant visible text and your current draft, then sends a prompt to your configured AI provider. The response is trimmed to remove text you have already typed, and the remaining suggestion appears in a floating overlay above the keyboard.

* **Single tap** on a suggestion to insert the next word.
* **Long press** to insert the entire suggestion at once.


# Advanced config
Source: https://docs.coreply.app/providers/advanced-config

Build a custom JSON request body using Mustache templates.

<Warning>
  The endpoint must still return the final assistant text in
  `choices[0].message.content`.
</Warning>

Advanced mode lets you edit the full request body that Coreply sends. Use it when the built-in provider forms are not enough.

## Enable advanced mode

<Steps>
  <Step title="Choose Advanced Mode">
    In Coreply, open **API Provider** and choose **Advanced Mode**.
  </Step>

  <Step title="Fill in the endpoint">
    Enter the full **Request URL**. If the endpoint uses bearer auth, fill in
    **Authorization Bearer**.
  </Step>

  <Step title="Edit the templates">
    Update the **Body Template** and **Suggestion Template** fields.
  </Step>
</Steps>

The body template uses [Mustache](https://mustache.github.io/). Coreply supplies the following context to the template and the resulting string is the request body.

## Current context format

Templates should start from `contexts`. It contains the structured contexts that Coreply has collected for the current request.

| Field          | Type   | Description                                                                                               |
| -------------- | ------ | --------------------------------------------------------------------------------------------------------- |
| `contexts`     | list   | Structured context objects. Use this when your backend understands Coreply context objects.               |
| `contextsJson` | string | The same `contexts` value pre-serialized as JSON. Use this when your request body needs a raw JSON array. |

Strings inside `contexts` are plain strings. If you need JSON-safe interpolation inside a string value, use the compatibility fields below or send `contexts` as structured JSON.

### Context objects

Each item in `contexts` has these top-level fields:

| Field       | Type   | Description                           |
| ----------- | ------ | ------------------------------------- |
| `type`      | string | `chat` or `screen`                    |
| `profileId` | string | The profile that produced the context |
| `label`     | string | Optional label such as `messages`     |
| `dropRule`  | object | Context retention rule metadata       |
| `data`      | object | The actual context payload            |

### Chat contexts

When `type` is `chat`, `data` has this shape:

| Field        | Type   | Description                 |
| ------------ | ------ | --------------------------- |
| `data.id`    | string | Optional chat identifier    |
| `data.title` | string | Optional chat title         |
| `data.turns` | list   | Conversation turns in order |

Each item in `data.turns`:

| Field      | Type    | Description                 |
| ---------- | ------- | --------------------------- |
| `sender`   | string  | Optional sender name        |
| `userSent` | boolean | `true` for the user's turns |
| `messages` | list    | Messages in that turn       |

Each item in `messages`:

| Field   | Type   | Description          |
| ------- | ------ | -------------------- |
| `body`  | string | Message text         |
| `time`  | string | Optional timestamp   |
| `quote` | string | Optional quoted text |

### Screen contexts

When `type` is `screen`, `data` is a text tree:

| Field           | Type   | Description                              |
| --------------- | ------ | ---------------------------------------- |
| `data.text`     | string | Optional text at this node               |
| `data.children` | list   | Optional child nodes with the same shape |

## Suggestion template

After the API call completes, Coreply reads `choices[0].message.content` from the JSON response and exposes it to the suggestion template.

| Field                                          | Type   | Description                                                                    |
| ---------------------------------------------- | ------ | ------------------------------------------------------------------------------ |
| `assistantMessage`                             | string | The raw text returned by the model                                             |
| `assistantMessageAutoTrimCurrentTyping`        | string | `assistantMessage` with `currentTyping` trimmed from the start when it matches |
| `assistantMessageAutoTrimCurrentTypingTrimmed` | string | Same as above, but trims `currentTypingTrimmed` instead                        |

### Show the response as-is

```text theme={null}
{{assistantMessage}}
```

### Prepend the user's current typing

```text theme={null}
{{currentTyping.raw}}{{assistantMessage}}
```

## Compatibility fields

Coreply still exposes the older `TypingInfo.contextMap` fields for compatibility. Use them when you want to build a plain chat prompt inside the JSON body. They only cover chat history and typing helpers. They do not include screen contexts.

### String map fields

Compatibility `string` fields are exposed as a string map with four variants:

| Variant                         | Description                           |
| ------------------------------- | ------------------------------------- |
| `{{field.raw}}`                 | Original unescaped string             |
| `{{field.jsonEscaped}}`         | JSON-escaped string                   |
| `{{field.regexLiteral}}`        | Regex-literal form of the string      |
| `{{field.regexLiteralEscaped}}` | Regex-literal form, then JSON-escaped |

In JSON string values, use `.jsonEscaped`.

### Compatibility top-level fields

| Field                            | Type       | Description                                         |
| -------------------------------- | ---------- | --------------------------------------------------- |
| `currentTyping`                  | string map | What the user is currently typing                   |
| `currentTypingTrimmed`           | string map | `currentTyping` without the last incomplete token   |
| `currentTypingLastToken`         | string map | The last incomplete token the user is typing        |
| `currentTypingEndsWithSeparator` | boolean    | `true` when typing ends with a space or punctuation |
| `pastMessages`                   | list       | Chat history only, grouped into turns               |

`pastMessages` does not include screen contexts. Use `contexts` if you need them.

### The `pastMessages` list

`{{#pastMessages}}...{{/pastMessages}}` iterates over chat turns from oldest to newest.

| Field      | Type       | Description                             |
| ---------- | ---------- | --------------------------------------- |
| `sent`     | boolean    | `true` if the turn was sent by the user |
| `received` | boolean    | `true` if the turn was received         |
| `sender`   | string map | Sender name or role                     |
| `messages` | list       | Messages inside the turn                |

Each item in `messages`:

| Field      | Type       | Description                |
| ---------- | ---------- | -------------------------- |
| `content`  | string map | Message text               |
| `sent`     | boolean    | `true` if sent by the user |
| `received` | boolean    | `true` if received         |
| `sender`   | string map | Sender name or role        |

### Compatibility example

```json theme={null}
{
  "model": "gpt-5.6-luna",
  "messages": [
    {
      "role": "system",
      "content": "You are an AI texting assistant. Generate a suggested reply based on the conversation history and current typing. Output only the suggested text without quotation marks or extra formatting."
    },
    {
      "role": "user",
      "content": "Chat history:\n{{#pastMessages}}{{#messages}}{{#sent}}Me: {{/sent}}{{#received}}Them: {{/received}}{{content.jsonEscaped}}\n{{/messages}}{{/pastMessages}}{{#currentTyping}}Current typing: {{currentTyping.jsonEscaped}}{{/currentTyping}}{{^currentTyping}}Suggest a reply.{{/currentTyping}}"
    }
  ],
  "max_tokens": 50,
  "stream": false
}
```

### Compatibility example with assistant prefill

```json theme={null}
{
  "model": "<your-model-name>",
  "messages": [
    {
      "role": "system",
      "content": "You are a texting assistant. Output only the suggested message text."
    },
    {
      "role": "user",
      "content": "{{#pastMessages}}{{#messages}}{{#sent}}Me: {{/sent}}{{#received}}Them: {{/received}}{{content.jsonEscaped}}\n{{/messages}}{{/pastMessages}}"
    },
    {
      "role": "assistant",
      "content": "{{#currentTyping}}{{currentTyping.jsonEscaped}}{{/currentTyping}}"
    }
  ],
  "max_tokens": 60,
  "stream": false
}
```

<Tip>
  Enable **Show errors** under [Configuration](/configuration/settings) while
  you are debugging templates.
</Tip>


# Azure OpenAI
Source: https://docs.coreply.app/providers/azure

Set up Coreply with Azure-hosted OpenAI deployments.

Use this provider when your OpenAI model is deployed through Azure OpenAI.

## Setup

<Steps>
  <Step title="Deploy a model in Azure OpenAI">
    Create an Azure deployment for a low-latency model such as `gpt-5.6-luna` or `gpt-5.6-terra`.
  </Step>

  <Step title="Choose Azure in the app">
    Open Coreply and choose **Azure** under **API Provider**.
  </Step>

  <Step title="Enter your Azure settings">
    Fill in the following values:

    | Field                     | Value                                             |
    | ------------------------- | ------------------------------------------------- |
    | Model                     | Your Azure deployment name                        |
    | API key                   | Your Azure OpenAI API key                         |
    | Resource name or Base URL | Provide one of them                               |
    | API version               | Fill this in if your Azure deployment requires it |
  </Step>

  <Step title="Disable reasoning">
    Set **Provider Options** to:

    ```json theme={null}
    {"azure": {"reasoningEffort": "none"}}
    ```
  </Step>
</Steps>

<Tip>
  In this provider, **Model** is your deployment name, not the raw upstream model ID.
</Tip>


# Coreply Cloud
Source: https://docs.coreply.app/providers/coreply-cloud

Use the hosted Coreply Cloud service to get AI suggestions with a single access key.

Coreply Cloud is the fastest way to get started. You create an account once, copy an access key, and paste it into Coreply.

## Setup

<Steps>
  <Step title="Create a Coreply Cloud account">
    Sign up at [coreply.up.nadles.com](https://coreply.up.nadles.com/) and copy your access key.
  </Step>

  <Step title="Choose Coreply Cloud in the app">
    Open Coreply and choose **Coreply Cloud** under **API Provider**.
  </Step>

  <Step title="Enter your key">
    Fill in the following values:

    | Field       | Value                                                            |
    | ----------- | ---------------------------------------------------------------- |
    | API key     | Your Coreply Cloud access key                                    |
    | Request URL | Leave the default value unless the dashboard instructs otherwise |
  </Step>
</Steps>

<Note>
  Coreply Cloud routes your conversation context through Coreply's backend before it reaches the model. If you want requests to go directly from your device to the model provider, use a self-configured provider such as [OpenAI-compatible API](/providers/openai-compatible).
</Note>


# Google AI Studio
Source: https://docs.coreply.app/providers/google-ai-studio

Set up Coreply with the Google Gemini API from AI Studio.

Coreply's `Google (Gemini API)` provider connects directly to the Gemini API. AI Studio is where you create the API key.

<Note>
  AI Studio's free tier has rate limits and is not available in every region. If you see the error `Unexpected JSON token at offset 0: Expected start of the object '{', but had '[' instead` — this is a rate limit response from Google, not a bug in Coreply. Wait a moment and try again, or switch to a paid tier.
</Note>

## Setup

<Steps>
  <Step title="Get your API key">
    Go to [aistudio.google.com/apikey](https://aistudio.google.com/apikey) and create a new API key.
  </Step>

  <Step title="Choose Google in the app">
    Open Coreply and choose **Google (Gemini API)** under **API Provider**.
  </Step>

  <Step title="Enter your settings">
    Fill in the following values:

    | Field            | Value                                                          |
    | ---------------- | -------------------------------------------------------------- |
    | API Key          | Your key from AI Studio                                        |
    | Model            | `gemini-3.5-flash-lite`                                        |
    | Provider Options | `{"google": {"thinkingConfig": {"thinkingLevel": "minimal"}}}` |
  </Step>

  <Step title="Choose a model">
    The following models are recommended for use with Coreply on AI Studio:

    ```text theme={null}
    gemini-3.5-flash-lite
    gemini-3.6-flash
    ```
  </Step>
</Steps>

<Warning>
  Current Gemini 3.x models do not fully turn thinking off. `minimal` is the lowest setting.
</Warning>


# Google Vertex
Source: https://docs.coreply.app/providers/google-vertex

Set up Coreply with Vertex AI to use Gemini models from your Google Cloud project.

Use this provider when you want Gemini through Vertex AI instead of the Gemini API from AI Studio.

## Setup

<Steps>
  <Step title="Choose Google Vertex in the app">
    Open Coreply and choose **Google Vertex** under **API Provider**.
  </Step>

  <Step title="Enter your Vertex settings">
    Fill in the following values:

    | Field                       | Value                                                        |
    | --------------------------- | ------------------------------------------------------------ |
    | Model                       | `gemini-3.5-flash-lite`                                      |
    | API key                     | Optional, if you use API-key auth                            |
    | Project                     | Your Google Cloud project ID if you use service-account auth |
    | Location                    | Your Vertex region if you use service-account auth           |
    | Service account credentials | Optional alternative to API-key auth                         |
  </Step>

  <Step title="Minimize thinking">
    Set **Provider Options** to:

    ```json theme={null}
    {"vertex": {"thinkingConfig": {"thinkingLevel": "minimal"}}}
    ```
  </Step>
</Steps>

## Recommended models

```text theme={null}
gemini-3.5-flash-lite
gemini-3.6-flash
```

<Note>
  Current Gemini 3.x models use `thinkingLevel`. `minimal` is the lowest setting. If you use an older Gemini 2.5 model instead, use `{"vertex": {"thinkingConfig": {"thinkingBudget": 0}}}`.
</Note>


# Groq
Source: https://docs.coreply.app/providers/groq

Set up Coreply with Groq for fast, low-latency inference on open-source models.

Groq offers extremely fast inference on popular open-source models and still has a free tier.

<Note>
  Groq's free tier has rate limits. If you encounter errors on the free tier, check whether you've hit your rate limit before reporting an issue.
</Note>

## Setup

<Steps>
  <Step title="Get your API key">
    Go to [console.groq.com/keys](https://console.groq.com/keys) and create a new API key.
  </Step>

  <Step title="Choose Groq in the app">
    Open Coreply and choose **Groq** under **API Provider**.
  </Step>

  <Step title="Enter your settings">
    Fill in the following values:

    | Field            | Value                                   |
    | ---------------- | --------------------------------------- |
    | API Key          | Your key from Groq                      |
    | Model            | `qwen/qwen3.8-27b`                      |
    | Provider Options | `{"groq": {"reasoningEffort": "none"}}` |
  </Step>

  <Step title="Choose a model">
    The following models are recommended for use with Coreply on Groq:

    ```text theme={null}
    qwen/qwen3.8-27b
    qwen/qwen3.6-27b
    llama-3.3-70b-versatile
    ```

    You're welcome to try other models available in Groq's model catalog.
  </Step>
</Steps>

<Tip>
  Models that support `reasoningEffort: none` are the best fit for Coreply. On Groq, that usually means Qwen 3.x models instead of GPT-OSS.
</Tip>


# MiniMax
Source: https://docs.coreply.app/providers/minimax

Set up Coreply with MiniMax for fast chat completions with optional thinking disabled.

Coreply supports MiniMax through the built-in `MiniMax` provider.

## Setup

<Steps>
  <Step title="Get your API key">
    Create an API key in [platform.minimax.io](https://platform.minimax.io/docs/guides/quickstart-preparation).
  </Step>

  <Step title="Choose MiniMax in the app">
    Open Coreply and choose **MiniMax** under **API Provider**.
  </Step>

  <Step title="Enter your settings">
    Fill in the following values:

    | Field   | Value                |
    | ------- | -------------------- |
    | API key | Your MiniMax API key |
    | Model   | `minimax-m3`         |
  </Step>

  <Step title="Disable thinking">
    Set **Provider Options** to:

    ```json theme={null}
    {"minimax": {"thinking": {"type": "disabled"}}}
    ```
  </Step>
</Steps>


# Mistral
Source: https://docs.coreply.app/providers/mistral

Set up Coreply with Mistral chat-completions models.

Use this provider for Mistral's regular chat-completions models. For the separate fill-in-the-middle provider, see [Mistral FIM](/providers/mistral-fim).

<Steps>
  <Step title="Get your API key">
    Go to [console.mistral.ai/api-keys](https://console.mistral.ai/api-keys) and create a new API key.
  </Step>

  <Step title="Choose Mistral in the app">
    Open Coreply and choose **Mistral** under **API Provider**.
  </Step>

  <Step title="Enter your settings">
    Fill in the following values:

    | Field   | Value                  |
    | ------- | ---------------------- |
    | API Key | Your key from Mistral  |
    | Model   | `mistral-small-latest` |
  </Step>

  <Step title="Choose a model">
    The following models are recommended for Coreply:

    ```text theme={null}
    mistral-small-latest
    mistral-small-2603
    ```

    You're welcome to try other models from Mistral's catalog.
  </Step>
</Steps>


# Mistral FIM
Source: https://docs.coreply.app/providers/mistral-fim

Set up Coreply with Mistral's fill-in-the-middle endpoint through Codestral.

This provider uses Mistral's fill-in-the-middle API instead of the normal chat-completions API.

## Setup

<Steps>
  <Step title="Get your API key">
    Go to [console.mistral.ai/api-keys](https://console.mistral.ai/api-keys) and create a new API key.
  </Step>

  <Step title="Choose Mistral FIM in the app">
    Open Coreply and choose **Mistral FIM** under **API Provider**.
  </Step>

  <Step title="Enter your settings">
    Fill in the following values:

    | Field    | Value                            |
    | -------- | -------------------------------- |
    | Base URL | `https://api.mistral.ai/v1/fim/` |
    | API key  | Your Mistral API key             |
    | Model    | `codestral-latest`               |
  </Step>
</Steps>

<Note>
  This provider calls Mistral's `/v1/fim/completions` endpoint. It is best when you want continuation-style completion from the current typing prefix.
</Note>


# OpenAI
Source: https://docs.coreply.app/providers/openai

Set up Coreply with OpenAI to use the latest GPT-5 low-latency tiers.

Coreply supports OpenAI's API directly. For real-time suggestions, use one of the explicit low-latency GPT-5 tiers and set reasoning to `none`.

## Setup

<Steps>
  <Step title="Get your API key">
    Go to [platform.openai.com/api-keys](https://platform.openai.com/api-keys) and create a new secret key.
  </Step>

  <Step title="Choose OpenAI in the app">
    Open Coreply and choose **OpenAI** under **API Provider**.
  </Step>

  <Step title="Enter your settings">
    Fill in the following values:

    | Field            | Value                                     |
    | ---------------- | ----------------------------------------- |
    | API Key          | Your secret key from OpenAI               |
    | Model            | `gpt-5.6-luna`                            |
    | Provider Options | `{"openai": {"reasoningEffort": "none"}}` |
  </Step>

  <Step title="Choose a model">
    The following models are recommended for use with Coreply:

    ```text theme={null}
    gpt-5.6-luna
    gpt-5.6-terra
    gpt-5.4-mini
    ```
  </Step>
</Steps>

## Model notes

<Warning>
  If you raise reasoning effort above `none`, suggestions will usually take
  longer to appear.
</Warning>


# OpenAI-compatible API
Source: https://docs.coreply.app/providers/openai-compatible

Set up Coreply with any OpenAI-compatible endpoint, including self-hosted and local servers.

Use this provider when your API speaks the OpenAI chat-completions format but is not one of Coreply's built-in integrations.

## Setup

<Steps>
  <Step title="Choose OpenAI Compatible in the app">
    Open Coreply and choose **OpenAI Compatible** under **API Provider**.
  </Step>

  <Step title="Enter your endpoint settings">
    Fill in the following values:

    | Field    | Value                                                                                   |
    | -------- | --------------------------------------------------------------------------------------- |
    | Name     | Leave `openAICompatible` unless you need a different namespace for **Provider Options** |
    | Base URL | Your OpenAI-compatible endpoint, such as `http://localhost:11434/v1`                    |
    | API key  | Your provider key, or any non-empty string if the endpoint does not enforce auth        |
    | Model    | The model ID expected by that endpoint                                                  |
  </Step>

  <Step title="Disable reasoning when supported">
    If the endpoint supports OpenAI-style reasoning controls, set **Provider Options** to:

    ```json theme={null}
    {"openAICompatible": {"reasoningEffort": "none"}}
    ```
  </Step>
</Steps>

<Tip>
  The key inside **Provider Options** must match the value in **Name**.
</Tip>

This provider also exposes the standard text-generation settings such as instructions, temperature, top-p, penalties, retries, timeout, and seed.

If you need a fully custom request body, use [Advanced config](/providers/advanced-config).


# OpenRouter
Source: https://docs.coreply.app/providers/openrouter

Set up Coreply with OpenRouter to access hundreds of models through a single API key.

OpenRouter is a unified API gateway that gives you access to models from many providers — including Google, OpenAI, Meta, and Mistral — through a single endpoint and API key.

<Note>
  Some OpenRouter endpoints are available for free with strict rate limits. Free models are fine for testing, but are not recommended for regular use. Paid models have higher limits and better availability.
</Note>

## Setup

<Steps>
  <Step title="Get your API key">
    Go to [openrouter.ai/settings/keys](https://openrouter.ai/settings/keys) and create a new API key.
  </Step>

  <Step title="Choose OpenRouter in the app">
    Open Coreply and choose **OpenRouter** under **API Provider**.
  </Step>

  <Step title="Enter your settings">
    Fill in the following values:

    | Field            | Value                                                                 |
    | ---------------- | --------------------------------------------------------------------- |
    | API Key          | Your key from OpenRouter                                              |
    | Model            | `openai/gpt-5.6-luna`                                                 |
    | Provider Options | `{"openrouter": {"reasoning": {"enabled": false, "effort": "none"}}}` |
  </Step>

  <Step title="Choose a model">
    These models are a good fit for Coreply:

    ```text theme={null}
    openai/gpt-5.6-luna
    google/gemini-3.5-flash-lite
    qwen/qwen3.8-27b
    ```

    You're welcome to try other models available on OpenRouter.
  </Step>
</Steps>

<Tip>
  OpenRouter lets you switch models without changing providers. For Coreply, prefer models that already support `none` or `minimal` reasoning.
</Tip>


# Providers
Source: https://docs.coreply.app/providers/overview

An overview of supported AI providers and how Coreply connects to them.

Coreply includes built-in integrations for major model providers, a generic OpenAI-compatible provider, and Advanced Mode for custom request bodies.

## What you need

To connect Coreply to a provider, you usually need:

* **An API key or access token**
* **A model name or deployment name**
* **Any provider-specific fields**, such as a base URL, project, location, or resource name

Many built-in providers also expose a **Provider Options** field. Use it for provider-specific reasoning or thinking controls.

## Choosing a model

For real-time texting, prefer models that either do not reason or can be set to `none` or `minimal` reasoning. The provider pages below show the current low-latency choices.

## Supported model families

The following model families work well with Coreply's prompt format:

| Model                | Supported |
| -------------------- | --------- |
| Llama 3 & 4 Family   | ✅         |
| Qwen 3 Family        | ✅         |
| OpenAI GPT Family    | ✅         |
| Google Gemini Family | ✅         |
| Mistral Family       | ✅         |
| Grok Family          | ✅         |

Many other models should also work. You're welcome to experiment with models not listed here.

## Provider setup guides

<CardGroup>
  <Card title="Coreply Cloud" icon="cloud" href="/providers/coreply-cloud">
    Use Coreply's hosted service with a single access key.
  </Card>

  <Card title="OpenAI-compatible API" icon="server" href="/providers/openai-compatible">
    Connect any endpoint that speaks the OpenAI chat-completions format.
  </Card>

  <Card title="Google AI Studio" icon="google" href="/providers/google-ai-studio">
    Use Gemini models through the Gemini API from AI Studio.
  </Card>

  <Card title="Google Vertex" icon="cloud" href="/providers/google-vertex">
    Use Gemini models from your Google Cloud project.
  </Card>

  <Card title="Groq" icon="bolt" href="/providers/groq">
    Fast inference on open-source models, including a free tier.
  </Card>

  <Card title="OpenRouter" icon="route" href="/providers/openrouter">
    Access hundreds of models from a single API key.
  </Card>

  <Card title="OpenAI" icon="microchip" href="/providers/openai">
    Use the latest GPT-5 low-latency tiers directly from OpenAI.
  </Card>

  <Card title="Azure OpenAI" icon="cloud" href="/providers/azure">
    Use Azure-hosted OpenAI deployments.
  </Card>

  <Card title="xAI" icon="sparkles" href="/providers/xai">
    Use Grok models directly from xAI.
  </Card>

  <Card title="Mistral" icon="wind" href="/providers/mistral">
    Use Mistral chat-completions models.
  </Card>

  <Card title="Mistral FIM" icon="braces" href="/providers/mistral-fim">
    Use Codestral through Mistral's fill-in-the-middle endpoint.
  </Card>

  <Card title="MiniMax" icon="cpu" href="/providers/minimax">
    Use MiniMax chat models with thinking disabled.
  </Card>

  <Card title="Vercel AI Gateway" icon="route" href="/providers/vercel-ai-gateway">
    Route requests through AI Gateway to upstream providers.
  </Card>

  <Card title="Advanced config" icon="sliders" href="/providers/advanced-config">
    Send a fully custom request body to an endpoint.
  </Card>
</CardGroup>


# Vercel AI Gateway
Source: https://docs.coreply.app/providers/vercel-ai-gateway

Set up Coreply with Vercel AI Gateway to route requests to upstream providers through one endpoint.

AI Gateway is a routing layer. You still choose an upstream model from another provider, such as OpenAI or Google.

## Setup

<Steps>
  <Step title="Create a gateway key">
    Create an AI Gateway key, or use a Vercel access token if that is how your gateway is configured.
  </Step>

  <Step title="Choose Vercel AI Gateway in the app">
    Open Coreply and choose **Vercel AI Gateway** under **API Provider**.
  </Step>

  <Step title="Enter your settings">
    Fill in the following values:

    | Field           | Value                                                                                       |
    | --------------- | ------------------------------------------------------------------------------------------- |
    | API key         | Your AI Gateway key or Vercel access token                                                  |
    | Model           | A namespaced upstream model such as `openai/gpt-5.6-luna` or `google/gemini-3.5-flash-lite` |
    | Team ID or slug | Optional                                                                                    |
  </Step>

  <Step title="Configure the upstream provider options">
    Use the upstream provider namespace in **Provider Options**. For example:

    ```json theme={null}
    {"openai": {"reasoningEffort": "none"}}
    ```

    or

    ```json theme={null}
    {"google": {"thinkingConfig": {"thinkingLevel": "minimal"}}}
    ```
  </Step>
</Steps>

<Tip>
  **Model** must use the provider-prefixed format that AI Gateway expects, such as `openai/...` or `google/...`.
</Tip>


# xAI
Source: https://docs.coreply.app/providers/xai

Set up Coreply with xAI to use Grok models directly.

Coreply supports xAI through the built-in `xAI` provider.

## Setup

<Steps>
  <Step title="Get your API key">
    Create an API key in [console.x.ai](https://console.x.ai/).
  </Step>

  <Step title="Choose xAI in the app">
    Open Coreply and choose **xAI** under **API Provider**.
  </Step>

  <Step title="Enter your settings">
    Fill in the following values:

    | Field   | Value            |
    | ------- | ---------------- |
    | API key | Your xAI API key |
    | Model   | `grok-4.3`       |
  </Step>

  <Step title="Disable reasoning">
    Set **Provider Options** to:

    ```json theme={null}
    {"xai": {"reasoningEffort": "none"}}
    ```
  </Step>
</Steps>

## Recommended models

```text theme={null}
grok-4.3
```

<Note>
  If you use `grok-4.6`, the lowest documented setting is `low`, so it is usually slower to first token than `grok-4.3` for Coreply.
</Note>


# Quick start
Source: https://docs.coreply.app/quickstart

Configure Coreply and get your first AI-powered suggestion in under 5 minutes.

<Tip>
  The fastest way to get started is Coreply Cloud. You sign up, copy an access
  key, and you're done. If you prefer to use your own provider, choose one of
  the built-in providers in step 2.
</Tip>

<Steps>
  <Step title="Open Coreply">
    Launch Coreply from your app drawer after [installing it](/installation). The main screen shows the service toggle and your current provider settings.
  </Step>

  <Step title="Choose an AI provider">
    Open **API Provider** on the main screen and choose one of the built-in providers.

    **Using Coreply Cloud:** choose **Coreply Cloud** and paste your access key.

    **Using your own endpoint:** choose a built-in provider such as **OpenAI**, **Groq**, or **Google (Gemini API)**. For a generic endpoint, choose **OpenAI Compatible** and fill in **Base URL**, **API Key**, and **Model**.

    See [Providers](/providers/overview) for provider-specific setup, recommended models, and low-reasoning settings.
  </Step>

  <Step title="Enable the Coreply service">
    Toggle the master switch in the app to **On**.

    Android will prompt you to grant the **accessibility permission**. Tap **Allow** and enable Coreply in the Accessibility settings screen.

    <Note>
      The accessibility permission is required. Coreply uses it to read relevant on-screen text and position the suggestion overlay above the keyboard. Without this permission, no suggestions will appear.
    </Note>
  </Step>

  <Step title="Open a supported app and start typing">
    Open WhatsApp, Signal, Instagram, Telegram, ChatGPT, Perplexity, or any other
    [supported app](/supported-apps) and navigate to a conversation. Begin typing
    a message — the Coreply suggestion overlay will appear after a brief pause.
  </Step>

  <Step title="Interact with suggestions">
    * **Single tap** a suggestion to insert the next word into your message.
    * **Long press** a suggestion to insert the full suggested text at once.

    Suggestions update continuously as you type, so you can keep typing and a new suggestion will follow.
  </Step>
</Steps>


# Supported apps
Source: https://docs.coreply.app/supported-apps

Android apps with app-specific Coreply support, including known limitations.

Coreply has app-specific support for the following Android apps. Apps marked with a limitation note may have reduced functionality in specific areas.

| App                  | Notes                                                                                 |
| -------------------- | ------------------------------------------------------------------------------------- |
| WhatsApp             | Full support                                                                          |
| WhatsApp Business    | Full support                                                                          |
| Instagram            | Full support                                                                          |
| Tinder               | Full support                                                                          |
| Signal               | Full support                                                                          |
| Hinge                | Full support                                                                          |
| LINE                 | Full support                                                                          |
| Heymandi             | Full support                                                                          |
| Telegram             | Full support                                                                          |
| Nekogram             | Full support                                                                          |
| Mattermost           | Limited role detection: Coreply cannot detect whether the message is sent or received |
| Facebook Messenger   | Performance issues: Coreply may not follow smoothly the animations and transitions    |
| Google Messages      | Performance issues: Coreply may not follow smoothly the animations and transitions    |
| Snapchat             | Limited role detection: Coreply cannot detect whether the message is sent or received |
| Microsoft Teams      | Full support                                                                          |
| Viber                | Full support                                                                          |
| Discord              | Full support                                                                          |
| Beeper               | Full support                                                                          |
| ChatGPT              |                                                                                       |
| Perplexity           |                                                                                       |
| Notification Replies | Performance issues; limited role detection                                            |

## Enabling Coreply for specific apps

You can control which apps Coreply is active in using the **Select Apps** feature in the app settings.

<Steps>
  <Step title="Open Coreply">
    Launch the Coreply app. The main screen shows the service controls and
    settings.
  </Step>

  <Step title="Tap Select Apps">
    Tap **Select Apps** to open the list of supported apps installed on your
    device.
  </Step>

  <Step title="Choose your apps">
    Toggle on the apps where you want Coreply to provide suggestions. Coreply
    will only activate in the apps you select.
  </Step>
</Steps>

# Using Coreply with unsupported apps

You can select apps that are not in the supported list. Coreply will try to extract the on screen text and provide suggestions. However, the behavior is not guaranteed. Please do not open issues for unsupported apps, unless you are certain the problem is due to a bug in Coreply.

<Note>
  Coreply cannot read images, videos, voice notes, or other non-text content.
  Suggestions may be limited in conversations that contain media.
</Note>

<Note>
  Coreply is not affiliated with or endorsed by any of the above-mentioned apps
  or their parent companies.
</Note>


# Troubleshooting
Source: https://docs.coreply.app/troubleshooting

Solutions to common problems you may encounter while using Coreply.

<AccordionGroup>
  <Accordion title="&#x22;Restricted Settings&#x22; dialog when enabling accessibility">
    Some Android versions show a "Restricted Settings" dialog when you try to grant the accessibility permission to Coreply, blocking you from enabling it.

    Follow the steps in [Google's guide for allowing restricted settings](https://support.google.com/android/answer/12623953?hl=en) to allow Coreply to use the accessibility service. After completing those steps, return to **Settings > Accessibility** and enable Coreply.
  </Accordion>

  <Accordion title="Suggestions don't appear in my app">
    Check the following in order:

    1. Open Coreply and confirm the master switch is **on**.
    2. Go to **Settings > Accessibility** on your device and verify that the Coreply accessibility service is enabled.
    3. In the Coreply app, tap **Select Apps** and confirm the app you are using is toggled on.

    If all three are correct and suggestions still don't appear, try closing and reopening the messaging app.
  </Accordion>

  <Accordion title="Unexpected JSON error or rate limit errors">
    If you see an error like:

    ```
    Unexpected JSON token at offset 0: Expected start of the object '{', but had '[' instead
    ```

    This typically means you have hit the rate limit of your AI provider. This is especially common with the **Google AI Studio free tier**, which has strict per-minute request limits.

    To resolve this:

    * Wait a moment before typing again, which reduces the number of API calls made.
    * Increase the debounce delay in **Coreply Settings** to space out requests.
    * Upgrade to a paid tier of your provider, or switch to a provider with a higher free quota such as Groq.
  </Accordion>

  <Accordion title="Banking apps block Coreply">
    Some Asian banking apps block apps from unknown sources that hold the accessibility permission, as a security measure. If a banking app on your device stops working after you enable Coreply, this is likely the cause.

    As a workaround, set up an [accessibility shortcut](https://support.google.com/accessibility/android/answer/7650693?hl=en#step_1) on your device. This lets you quickly toggle Coreply on and off — disable it before opening your banking app and re-enable it afterwards.

    <Note>
      A future Play Store listing for Coreply may resolve this issue, as apps distributed through the Play Store are typically treated differently by banking security systems.
    </Note>
  </Accordion>

  <Accordion title="WhatsApp shows &#x22;Message&#x22; hint text as typed text">
    On devices running **Android 12 or lower**, WhatsApp's placeholder text "Message" may be treated as typed text by Coreply, causing suggestions to appear even when the text field is empty.

    This is a known issue. There is no fix currently available. Upgrading to Android 13 or higher resolves the problem.
  </Accordion>

  <Accordion title="Suggestions don't appear for images, videos, or voice messages">
    Coreply can only read text content from the conversation. It cannot process images, videos, voice notes, or any other non-text media.

    When a conversation contains only media or the most recent message is non-text, suggestions may not appear or may be based on older text context. This is a known limitation with no current workaround.
  </Accordion>

  <Accordion title="RTL languages have limited support">
    Right-to-left (RTL) language support in Coreply is limited. You may experience layout issues with the suggestion overlay or incorrect text insertion behavior when typing in languages such as Arabic, Hebrew, or Persian.

    This is a known limitation. Improved RTL support is not yet available.
  </Accordion>

  <Accordion title="Suggestions feel slow">
    Slow suggestions are usually caused by a high-latency AI provider or model. Try the following:

    * **Switch to Groq** — Groq offers very low inference latency and is one of the fastest free options available.
    * **Reduce the debounce delay** — In **Coreply Settings**, lower the debounce delay so suggestions are requested sooner after you stop typing.
    * **Avoid reasoning-heavy model tiers** — Use the recommended low-latency models on each [provider page](/providers/overview).
  </Accordion>

  <Accordion title="Coreply doesn't follow app animations">
    In some apps, the suggestion overlay may lag behind or not track correctly during animations and transitions. This is a known performance issue that affects:

    * **Facebook Messenger**
    * **Google Messages**
    * **Notification Replies**

    There is no fix currently available. The overlay will reposition correctly once the animation completes.
  </Accordion>
</AccordionGroup>