TypeScript
```typescript
import { CopilotClient, RuntimeConnection } from "@github/copilot-sdk";
const client = new CopilotClient({
connection: RuntimeConnection.forUri("localhost:4321"),
mode: "empty",
});
const session = await client.createSession({
sessionId: `user-${userId}-${Date.now()}`,
model: "gpt-5.4",
availableTools: ["custom:*"],
gitHubToken: user.githubToken,
});
const response = await session.sendAndWait({ prompt: req.body.message });
res.json({ content: response?.data.content });
```
Python
```python
from copilot import CopilotClient, RuntimeConnection
from copilot.session import PermissionHandler
client = CopilotClient(
connection=RuntimeConnection.for_uri("localhost:4321"),
)
await client.start()
session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-5.4", session_id=f"user-{user_id}-{int(time.time())}")
response = await session.send_and_wait(message)
```
Go
```golang
client := copilot.NewClient(&copilot.ClientOptions{
Connection: copilot.URIConnection{URL: "localhost:4321"},
})
client.Start(ctx)
defer client.Stop()
session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
SessionID: fmt.Sprintf("user-%s-%d", userID, time.Now().Unix()),
Model: "gpt-5.4",
})
response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: message})
```
.NET
```csharp
var client = new CopilotClient(new CopilotClientOptions
{
Connection = RuntimeConnection.ForUri("localhost:4321"),
});
await using var session = await client.CreateSessionAsync(new SessionConfig
{
SessionId = $"user-{userId}-{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}",
Model = "gpt-5.4",
});
var response = await session.SendAndWaitAsync(
new MessageOptions { Prompt = message });
```
Java
```java
import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;
var userId = "user1";
var message = "Hello!";
var client = new CopilotClient(new CopilotClientOptions()
.setCliUrl("localhost:4321")
);
try {
client.start().get();
var session = client.createSession(new SessionConfig()
.setSessionId(String.format("user-%s-%d", userId, System.currentTimeMillis() / 1000))
.setModel("gpt-5.4")
.setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();
var response = session.sendAndWait(new MessageOptions()
.setPrompt(message)).get();
} finally {
client.stop().get();
}
```
## Authentication for backend services
### Environment variable tokens
The simplest approach—set a token on the CLI server:
```bash
# All requests use this token
export COPILOT_GITHUB_TOKEN="gho_service_account_token"
copilot --headless --port 4321
```
### Per-user tokens (OAuth)
Pass individual user tokens when creating sessions. See [GitHub OAuth setup](/en/copilot/how-tos/copilot-sdk/setup/github-oauth) for the full flow.
```typescript
const client = new CopilotClient({
connection: RuntimeConnection.forUri("localhost:4321"),
mode: "empty",
});
// Your API receives user tokens from your auth layer
app.post("/chat", authMiddleware, async (req, res) => {
const session = await client.createSession({
sessionId: `user-${req.user.id}-chat`,
model: "gpt-5.4",
availableTools: ["custom:*"],
gitHubToken: req.user.githubToken,
});
const response = await session.sendAndWait({
prompt: req.body.message,
});
res.json({ content: response?.data.content });
});
```
### BYOK (no GitHub auth)
Use your own API keys for the model provider. See [BYOK (bring your own key)](/en/copilot/how-tos/copilot-sdk/auth/byok) for details.
```typescript
const client = new CopilotClient({
connection: RuntimeConnection.forUri("localhost:4321"),
});
const session = await client.createSession({
model: "gpt-5.4",
provider: {
type: "openai",
baseUrl: "https://api.openai.com/v1",
apiKey: process.env.OPENAI_API_KEY,
},
});
```
## Common backend patterns
### Web API with Express
```typescript
import express from "express";
import { CopilotClient, RuntimeConnection } from "@github/copilot-sdk";
const app = express();
app.use(express.json());
// Single shared CLI connection for multi-user server mode
const client = new CopilotClient({
connection: RuntimeConnection.forUri(process.env.CLI_URL || "localhost:4321"),
mode: "empty",
});
app.post("/api/chat", async (req, res) => {
const { sessionId, message } = req.body;
// Create or resume session
let session;
try {
session = await client.resumeSession(sessionId);
} catch {
session = await client.createSession({
sessionId,
model: "gpt-5.4",
availableTools: ["custom:*"],
gitHubToken: req.user.githubToken,
});
}
const response = await session.sendAndWait({ prompt: message });
res.json({
sessionId,
content: response?.data.content,
});
});
app.listen(3000);
```
### Background worker
```typescript
import { CopilotClient, RuntimeConnection } from "@github/copilot-sdk";
const client = new CopilotClient({
connection: RuntimeConnection.forUri(process.env.CLI_URL || "localhost:4321"),
});
// Process jobs from a queue
async function processJob(job: Job) {
const session = await client.createSession({
sessionId: `job-${job.id}`,
model: "gpt-5.4",
});
const response = await session.sendAndWait({
prompt: job.prompt,
});
await saveResult(job.id, response?.data.content);
await session.disconnect(); // Clean up after job completes
}
```
### Docker compose deployment
```yaml
version: "3.8"
services:
copilot-cli:
image: copilot-cli:latest # See "Step 1" above for how to build this image
command: ["--headless", "--host", "0.0.0.0", "--port", "4321"]
environment:
- COPILOT_GITHUB_TOKEN=${COPILOT_GITHUB_TOKEN}
ports:
- "4321:4321"
restart: always
volumes:
- session-data:/root/.copilot/session-state
api:
build: .
environment:
- CLI_URL=copilot-cli:4321
depends_on:
- copilot-cli
ports:
- "3000:3000"
volumes:
session-data:
```
## Health checks
Monitor the CLI server's health:
```typescript
// Periodic health check
async function checkCLIHealth(): Promise