> ## Documentation Index
> Fetch the complete documentation index at: https://docs.readmin.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Starting Calls from Your Game

> Open the ReAdmin support panel from your own UI, or start a support call directly from client or server code.

## Overview

ReAdmin ships with a built-in topbar button players use to **request support** or
**report a player**. Those requests become live [Calls](/features/calls) your staff
work from the dashboard, with two-way chat in-game.

Sometimes you want to trigger that flow yourself — from your **own** button, a
proximity prompt, a keybind, an NPC, or an automated rule — without using the
ReAdmin topbar. This page covers the three ways to do that:

| You want to…                                                        | Use                                           | Runs on |
| ------------------------------------------------------------------- | --------------------------------------------- | ------- |
| Open ReAdmin's built-in support / report form from your own UI      | **Client API** → `openSupport` / `openReport` | Client  |
| Start a call directly (no form), e.g. from a "Talk to staff" button | **Client API** → `createCall`                 | Client  |
| Start a call from trusted server logic (NPC, rule, command)         | **Server API** → `ReAdmin.StartSupportChat`   | Server  |

All three create the exact same ticket the topbar does: it appears in your
[Calls](/features/calls) queue, every message is run through Roblox text
filtering, and a player can only ever have **one open ticket at a time**.

<Note>
  Calls must be enabled for your workspace. Turn it on under
  [Remote Admin settings](/settings/remote-admin) and make sure the
  [Activity Tracking module is installed](/settings/downloads).
</Note>

## Client API

When the Activity Tracking module loads, the ReAdmin client publishes a
`BindableFunction` named **`ReAdminClientAPI`** into `ReplicatedStorage`. Because
it's a `BindableFunction`, only **your own LocalScripts** on the same client can
reach it — it adds no new network surface for exploiters.

```lua theme={null}
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ReAdminClient = ReplicatedStorage:WaitForChild("ReAdminClientAPI")
```

<Tip>
  Use `WaitForChild` — your LocalScript may run before the ReAdmin client has
  finished setting up. `WaitForChild` simply yields until it's ready.
</Tip>

### Open the built-in form

Open ReAdmin's polished support panel from your own button instead of the topbar:

```lua theme={null}
-- "Request Support" form
ReAdminClient:Invoke("openSupport")

-- "Report a Player" form (with the in-server player auto-fill picker)
ReAdminClient:Invoke("openReport")
```

There's also a generic `open` action if you'd rather pass the view as an option:

```lua theme={null}
ReAdminClient:Invoke("open", { view = "report" }) -- or view = "support"
```

If the player already has an active call, opening the form jumps straight to the
live chat instead.

### Start a call directly

Skip the form entirely and start a call straight from your own UI. The player's
live chat window opens automatically so they can talk to your staff:

```lua theme={null}
-- Support call
local ticket = ReAdminClient:Invoke("createCall", {
    reason = "I need a hand with my base",
})

-- Report call
ReAdminClient:Invoke("createCall", {
    callType  = "report",
    reporting = "Builderman",        -- username being reported
    reason    = "Exploiting near spawn",
})
```

`createCall` returns the ticket on success. If the player already has an open
call, it returns that existing ticket instead of creating a duplicate.

### Helpers

```lua theme={null}
-- Is the player currently in a support call?
local inCall = ReAdminClient:Invoke("isInCall") -- boolean

-- End the player's current call
ReAdminClient:Invoke("endCall")
```

### Client API reference

| Action        | Options                            | Returns   | Description                                         |
| ------------- | ---------------------------------- | --------- | --------------------------------------------------- |
| `openSupport` | –                                  | `true`    | Opens the built-in **Request Support** form.        |
| `openReport`  | –                                  | `true`    | Opens the built-in **Report a Player** form.        |
| `open`        | `{ view = "support" \| "report" }` | `true`    | Opens the requested form (defaults to support).     |
| `createCall`  | `{ reason, callType, reporting }`  | `ticket`  | Starts a call without the form and opens live chat. |
| `isInCall`    | –                                  | `boolean` | Whether the player has an active call.              |
| `endCall`     | –                                  | `true`    | Ends the player's current call.                     |

**`createCall` options**

| Option      | Type                    | Default     | Description                                               |
| ----------- | ----------------------- | ----------- | --------------------------------------------------------- |
| `reason`    | `string`                | `""`        | What the player needs help with / what they're reporting. |
| `callType`  | `"support" \| "report"` | `"support"` | The kind of call to create.                               |
| `reporting` | `string`                | –           | For `report` calls, the username being reported.          |

## Server API

The loader **returns** a ReAdmin table. Keep a handle to it and you can start a
support chat from trusted server code — an NPC interaction, a proximity prompt,
or an automated rule — without the player touching any UI. Their chat window
opens automatically and they can reply just like a normal call.

```lua theme={null}
local ReAdmin = require(YOUR_LOADER_ASSET_ID)({
    loaderId = "your-loader-id-here",
    afkTime = 45,
})

-- Start a support chat with a player from server code
local ticket, err = ReAdmin.StartSupportChat(player, {
    reason = "Our team noticed you may need help with the tutorial",
})

if not ticket then
    warn("Could not start support chat:", err)
end
```

<Note>
  The server API is intentionally **server-only** — it's not exposed as a
  client-invokable remote, so exploiters can't spam it. Call it from code you
  trust.
</Note>

### Methods

```lua theme={null}
-- Start a chat. options = { reason: string?, callType: string?, reporting: boolean? }
-- Returns (ticket, nil) on success or (nil, errorMessage) on failure.
local ticket, err = ReAdmin.StartSupportChat(player, { reason = "…" })

-- Is the player currently in a support chat? -> boolean
local inChat = ReAdmin.IsInSupportChat(player)

-- End the player's chat. Returns (true, nil) or (false, errorMessage).
local ok, err = ReAdmin.EndSupportChat(player)
```

| Method             | Parameters           | Returns                              |
| ------------------ | -------------------- | ------------------------------------ |
| `StartSupportChat` | `player`, `options?` | `ticket, nil` or `nil, errorMessage` |
| `IsInSupportChat`  | `player`             | `boolean`                            |
| `EndSupportChat`   | `player`             | `true, nil` or `false, errorMessage` |

**`StartSupportChat` options**

| Option      | Type                    | Default     | Description                                          |
| ----------- | ----------------------- | ----------- | ---------------------------------------------------- |
| `reason`    | `string`                | –           | What the chat is about. Shown to staff in the queue. |
| `callType`  | `"support" \| "report"` | `"support"` | The kind of call to create.                          |
| `reporting` | `boolean`               | `false`     | Marks the call as a report.                          |

## Good to know

* **One open ticket per player.** Starting a call when the player already has an
  open ticket returns the existing ticket rather than creating a duplicate.
* **Everything is filtered.** Every message is run through Roblox text filtering
  before it's shown to anyone.
* **It all lands in Calls.** However a call is started, it shows up in your live
  [Calls](/features/calls) queue for staff to claim, chat, and resolve.

## Related pages

* [In-Game Support](/features/in-game-support)
* [Calls](/features/calls)
* [Embedding the Application Center](/api-reference/application-center)
* [Remote Admin](/settings/remote-admin)
* [Custom Remote Admin Commands](/api-reference/custom-commands)