Xray API Documents

https://github.com/xtls/xray-api-documents
Admin
Xray API Documents provides gRPC API documentation and examples for integrating with the Xray proxy...
Tokens:6,797
Snippets:23
Trust Score:8.8
Update:8 months ago
Show doc for...
Tokens:
Raw
### GetSysStats - Get System Statistics

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Retrieves runtime statistics of the Xray instance, including memory usage, goroutine count, garbage collection stats, and uptime.

```APIDOC
## GetSysStats

### Description
Retrieves runtime statistics of the Xray instance including memory usage, goroutine count, garbage collection stats, and uptime.

### Method
`POST` (Assumed, as it modifies or retrieves state via a command service)

### Endpoint
`/stats/command/sys` (Assumed based on Go client usage)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{} 
```

### Response
#### Success Response (200)
- **numGoroutine** (integer) - The number of active goroutines.
- **numGC** (integer) - The number of garbage collection cycles.
- **alloc** (integer) - Memory allocated in bytes.
- **totalAlloc** (integer) - Total memory allocated throughout the lifetime of the process in bytes.
- **sys** (integer) - System memory obtained in bytes.
- **mallocs** (integer) - The total number of memory allocations.
- **frees** (integer) - The total number of memory deallocations.
- **liveObjects** (integer) - The number of live objects in memory.
- **pauseTotalNs** (integer) - The total time spent in garbage collection pauses in nanoseconds.
- **uptime** (integer) - The uptime of the Xray instance in seconds.

#### Response Example
```json
{
  "numGoroutine": 17,
  "numGC": 2,
  "alloc": 1711192,
  "totalAlloc": 2359880,
  "sys": 14440840,
  "mallocs": 19101,
  "frees": 7242,
  "liveObjects": 11859,
  "pauseTotalNs": 4983200,
  "uptime": 31
}
```
```

--------------------------------

### GetSysStats - Get System Statistics (Go)

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Retrieves runtime statistics of the Xray instance, including memory usage, goroutine count, garbage collection stats, and uptime. It takes the stats client as input and returns a system statistics response object or an error.

```go
package main

import (
    "context"
    "fmt"

    statsService "github.com/xtls/xray-core/app/stats/command"
)

func getSysStats(c statsService.StatsServiceClient) (*statsService.SysStatsResponse, error) {
    stats, err := c.GetSysStats(context.Background(), &statsService.SysStatsRequest{})
    return stats, err
}

// Usage:
// stats, err := getSysStats(xrayCtl.SsClient)
// if err != nil {
//     log.Fatalf("Failed to get stats: %s", err)
// }
// fmt.Println(stats)
// Output:
// NumGoroutine:17 NumGC:2 Alloc:1711192 TotalAlloc:2359880 Sys:14440840
// Mallocs:19101 Frees:7242 LiveObjects:11859 PauseTotalNs:4983200 Uptime:31

// Access individual fields:
// fmt.Printf("Goroutines: %d\n", stats.NumGoroutine)
// fmt.Printf("Memory Allocated: %d bytes\n", stats.Alloc)
// fmt.Printf("Uptime: %d seconds\n", stats.Uptime)
```

--------------------------------

### Initialize XrayController - Go

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Demonstrates how to initialize the XrayController, which establishes a gRPC connection to the Xray API and sets up clients for HandlerService, StatsService, and LoggerService. This is a prerequisite for all other API operations.

```go
package main

import (
    "fmt"
    "log"

    loggerService "github.com/xtls/xray-core/app/log/command"
    handlerService "github.com/xtls/xray-core/app/proxyman/command"
    statsService "github.com/xtls/xray-core/app/stats/command"
    "google.golang.org/grpc"
)

// BaseConfig holds the Xray API connection settings
type BaseConfig struct {
    APIAddress string
    APIPort    uint16
}

// XrayController manages all Xray API service clients
type XrayController struct {
    HsClient handlerService.HandlerServiceClient
    SsClient statsService.StatsServiceClient
    LsClient loggerService.LoggerServiceClient
    CmdConn  *grpc.ClientConn
}

func (xrayCtl *XrayController) Init(cfg *BaseConfig) error {
    var err error
    xrayCtl.CmdConn, err = grpc.Dial(
        fmt.Sprintf("%s:%d", cfg.APIAddress, cfg.APIPort),
        grpc.WithInsecure(),
    )
    if err != nil {
        return err
    }

    xrayCtl.HsClient = handlerService.NewHandlerServiceClient(xrayCtl.CmdConn)
    xrayCtl.SsClient = statsService.NewStatsServiceClient(xrayCtl.CmdConn)
    xrayCtl.LsClient = loggerService.NewLoggerServiceClient(xrayCtl.CmdConn)
    return nil
}

func main() {
    xrayCtl := new(XrayController)
    cfg := &BaseConfig{
        APIAddress: "127.0.0.1",
        APIPort:    10085,
    }

    if err := xrayCtl.Init(cfg); err != nil {
        log.Fatalf("Failed to initialize: %s", err)
    }
    defer xrayCtl.CmdConn.Close()

    fmt.Println("Successfully connected to Xray API")
}

```

--------------------------------

### AddInbound - Create a New Inbound Handler

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Creates a new inbound proxy handler with full configuration including port, transport settings (WebSocket, TCP, etc.), TLS encryption, and initial user accounts. This allows dynamic addition of proxy endpoints without modifying configuration files.

```APIDOC
## AddInbound - Create a New Inbound Handler

### Description
Creates a new inbound proxy handler with full configuration including port, transport settings (WebSocket, TCP, etc.), TLS encryption, and initial user accounts. This allows dynamic addition of proxy endpoints without modifying configuration files.

### Method
POST

### Endpoint
/AddInbound

### Parameters
#### Request Body
- **Inbound** (core.InboundHandlerConfig) - Required - The configuration for the inbound handler.
  - **Tag** (string) - Required - Unique identifier for this inbound.
  - **ReceiverSettings** (proxyman.ReceiverConfig) - Required - Settings for the receiver.
    - **PortList** (net.PortList) - Required - List of ports to listen on.
      - **Range** ([]*net.PortRange) - Required - Port ranges.
    - **Listen** (net.IPOrDomain) - Optional - The IP address to listen on (defaults to 0.0.0.0).
    - **SniffingSettings** (proxyman.SniffingConfig) - Optional - Configuration for traffic sniffing.
      - **Enabled** (bool) - Required - Whether sniffing is enabled.
      - **DestinationOverride** ([]string) - Optional - List of protocols to override.
    - **StreamSettings** (internet.StreamConfig) - Required - Transport and security settings.
      - **ProtocolName** (string) - Required - The name of the protocol (e.g., "websocket").
      - **TransportSettings** ([]*internet.TransportConfig) - Optional - List of transport layer configurations.
      - **SecurityType** (string) - Required - The type of security (e.g., TLS).
      - **SecuritySettings** ([]*serial.TypedMessage) - Optional - Security specific settings.
  - **ProxySettings** (interface{}) - Required - Proxy protocol specific settings (e.g., VMess).
    - **User** ([]*protocol.User) - Required - List of initial users.
      - **Level** (uint32) - Required - User level.
      - **Email** (string) - Required - User email.
      - **Account** (interface{}) - Required - User account details (e.g., VMess Account).

### Request Example
```json
{
  "Inbound": {
    "Tag": "proxy0",
    "ReceiverSettings": {
      "PortList": {
        "Range": [
          {
            "From": 12360,
            "To": 12360
          }
        ]
      },
      "Listen": "0.0.0.0",
      "SniffingSettings": {
        "Enabled": true,
        "DestinationOverride": [
          "http",
          "tls"
        ]
      },
      "StreamSettings": {
        "ProtocolName": "websocket",
        "TransportSettings": [
          {
            "ProtocolName": "websocket",
            "Settings": {
              "@type": "type.googleapis.com/xray.transport.internet.websocket.Config",
              "Path": "/web",
              "Header": {
                "Host": "www.xray.best"
              }
            }
          }
        ],
        "SecurityType": "type.googleapis.com/xray.transport.internet.tls.Config",
        "SecuritySettings": [
          {
            "@type": "type.googleapis.com/xray.transport.internet.tls.Config",
            "Certificate": [
              {
                "Certificate": "...base64 encoded cert...",
                "Key": "...base64 encoded key..."
              }
            ]
          }
        ]
      }
    },
    "ProxySettings": {
      "@type": "type.googleapis.com/xray.proxy.vmess.inbound.Config",
      "User": [
        {
          "Level": 0,
          "Email": "love@xray.com",
          "Account": {
            "@type": "type.googleapis.com/xray.common.protocol.vmess.Account",
            "Id": "10354ac4-9ec1-4864-ba3e-f5fd35869ef8"
          }
        }
      ]
    }
  }
}
```

### Response
#### Success Response (200)
- **Empty response body on success**

#### Response Example
(No response body)
```

--------------------------------

### AddInbound - Create New Inbound Handler (Go)

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Creates a new inbound proxy handler with specified port, transport settings (WebSocket, TCP, etc.), TLS encryption, and initial user accounts. This function allows dynamic addition of proxy endpoints without modifying configuration files. It requires the `command.HandlerServiceClient` from the Xray core library.

```go
package main

import (
    "context"
    "log"

    "github.com/xtls/xray-core/app/proxyman"
    "github.com/xtls/xray-core/app/proxyman/command"
    "github.com/xtls/xray-core/common/net"
    "github.com/xtls/xray-core/common/protocol"
    "github.com/xtls/xray-core/common/protocol/tls/cert"
    "github.com/xtls/xray-core/common/serial"
    "github.com/xtls/xray-core/core"
    "github.com/xtls/xray-core/proxy/vmess"
    vmessInbound "github.com/xtls/xray-core/proxy/vmess/inbound"
    "github.com/xtls/xray-core/transport/internet"
    "github.com/xtls/xray-core/transport/internet/tls"
    "github.com/xtls/xray-core/transport/internet/websocket"
)

func addInbound(client command.HandlerServiceClient) error {
    _, err := client.AddInbound(context.Background(), &command.AddInboundRequest{
        Inbound: &core.InboundHandlerConfig{
            Tag: "proxy0",  // Unique identifier for this inbound
            ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{
                // Listen on port 12360
                PortList: &net.PortList{
                    Range: []*net.PortRange{net.SinglePortRange(12360)},
                },
                Listen: net.NewIPOrDomain(net.AnyIP),  // 0.0.0.0
                // Traffic sniffing configuration
                SniffingSettings: &proxyman.SniffingConfig{
                    Enabled:             true,
                    DestinationOverride: []string{"http", "tls"},
                },
                // Transport settings - WebSocket over TLS
                StreamSettings: &internet.StreamConfig{
                    ProtocolName: "websocket",
                    TransportSettings: []*internet.TransportConfig{
                        {
                            ProtocolName: "websocket",
                            Settings: serial.ToTypedMessage(&websocket.Config{
                                Path: "/web",
                                Header: map[string]string{
                                    "Host": "www.xray.best",
                                },
                            }),
                        },
                    },
                    SecurityType: serial.GetMessageType(&tls.Config{}),
                    SecuritySettings: []*serial.TypedMessage{
                        serial.ToTypedMessage(&tls.Config{
                            Certificate: []*tls.Certificate{
                                tls.ParseCertificate(cert.MustGenerate(nil)),
                            },
                        }),
                    },
                },
            }),
            // VMess proxy with initial user
            ProxySettings: serial.ToTypedMessage(&vmessInbound.Config{
                User: []*protocol.User{
                    {
                        Level: 0,
                        Email: "love@xray.com",
                        Account: serial.ToTypedMessage(&vmess.Account{
                            Id: "10354ac4-9ec1-4864-ba3e-f5fd35869ef8",
                        }),
                    },
                },
            }),
        },
    })
    return err
}

// Usage:
// err := addInbound(xrayCtl.HsClient)
// if err != nil {
//     log.Printf("Failed to add inbound: %s", err)
// }

```

--------------------------------

### RestartLogger - Restart the Logger Service (Go)

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Restarts the Xray logging service, which is useful for log rotation or reloading log configuration. It takes the logger service client as input and returns an error if the restart fails.

```go
package main

import (
    "context"
    "log"

    loggerService "github.com/xtls/xray-core/app/log/command"
)

func restartLogger(c loggerService.LoggerServiceClient) error {
    _, err := c.RestartLogger(context.Background(), &loggerService.RestartLoggerRequest{})
    return err
}

// Usage:
// err := restartLogger(xrayCtl.LsClient)
// if err != nil {
//     log.Printf("Failed to restart logger: %s", err)
// }
// Output: Logger service restarted successfully
```

--------------------------------

### QueryStats - Query Traffic Statistics (Go)

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Queries traffic statistics (uplink/downlink) for users, inbound, or outbound handlers. Supports an optional reset of the traffic counter after the query. It takes the client, a pattern string, and a boolean for reset as input. Returns traffic in bytes or an error.

```go
package main

import (
    "context"
    "fmt"

    statsService "github.com/xtls/xray-core/app/stats/command"
)

// Query patterns:
// - User traffic: "user>>>email@example.com>>>traffic>>>uplink" or ">>>downlink"
// - Inbound traffic: "inbound>>>tag>>>traffic>>>uplink" or ">>>downlink"
// - Outbound traffic: "outbound>>>tag>>>traffic>>>uplink" or ">>>downlink"

func queryTraffic(c statsService.StatsServiceClient, pattern string, reset bool) (int64, error) {
    traffic := int64(-1)  // -1 indicates not found

    resp, err := c.QueryStats(context.Background(), &statsService.QueryStatsRequest{
        Pattern: pattern,
        Reset_:  reset,  // Reset traffic counter after query
    })
    if err != nil {
        return traffic, err
    }

    stat := resp.GetStat()
    if len(stat) != 0 {
        traffic = stat[0].Value  // Traffic in bytes
    }
    return traffic, nil
}

// Usage - Query inbound downlink traffic:
// traffic, err := queryTraffic(xrayCtl.SsClient, "inbound>>>proxy0>>>traffic>>>downlink", false)
// fmt.Printf("Downlink traffic: %d bytes\n", traffic)
// Output: Downlink traffic: 348789 bytes

// Usage - Query user uplink traffic and reset:
// traffic, err := queryTraffic(xrayCtl.SsClient, "user>>>love@xray.com>>>traffic>>>uplink", true)
// fmt.Printf("Uplink traffic: %d bytes (counter reset)\n", traffic)
```

--------------------------------

### GetInboundUsers - List Users in an Inbound (Go)

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Retrieves all users configured in an inbound handler or filters by a specific email address. It takes the client, inbound tag, and an optional email as input. Returns a list of users or an error.

```go
package main

import (
    "context"
    "fmt"

    "github.com/xtls/xray-core/app/proxyman/command"
)

func getInboundUsers(client command.HandlerServiceClient, tag string, email string) (*command.GetInboundUserResponse, error) {
    users, err := client.GetInboundUsers(context.Background(), &command.GetInboundUserRequest{
        Tag:   tag,
        Email: email,  // Empty string returns all users
    })
    return users, err
}

// Usage - Get all users:
// users, err := getInboundUsers(xrayCtl.HsClient, "proxy0", "")
// fmt.Println(users)
// Output: users:{email:"love@xray.com" account:{type:"xray.proxy.vmess.Account" value:"\n$10354ac4-9ec1-4864-ba3e-f5fd35869ef8\x1a\x02\x08\x04"}}

// Usage - Get specific user:
// users, err := getInboundUsers(xrayCtl.HsClient, "proxy0", "love@xray.com")
```

--------------------------------

### Add VMess User to Inbound Handler - Go

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Adds a new VMess user to a specified inbound handler. Requires the Xray core command service client, user details including UUID, level, inbound tag, and email. The user's account is configured as a VMess account.

```go
package main

import (
    "context"

    "github.com/xtls/xray-core/app/proxyman/command"
    "github.com/xtls/xray-core/common/protocol"
    "github.com/xtls/xray-core/common/serial"
    "github.com/xtls/xray-core/proxy/vmess"
)

type UserInfo struct {
    Uuid       string
    Level      uint32
    InTag      string  // Target inbound tag
    Email      string  // Unique identifier
    CipherType string  // For ShadowSocks
    Password   string  // For ShadowSocks/Trojan
}

func addVmessUser(client command.HandlerServiceClient, user *UserInfo) error {
    _, err := client.AlterInbound(context.Background(), &command.AlterInboundRequest{
        Tag: user.InTag,
        Operation: serial.ToTypedMessage(&command.AddUserOperation{
            User: &protocol.User{
                Level: user.Level,
                Email: user.Email,
                Account: serial.ToTypedMessage(&vmess.Account{
                    Id: user.Uuid,
                }),
            },
        }),
    })
    return err
}

// Usage:
// user := &UserInfo{
//     Uuid:  "10354ac4-9ec1-4864-ba3e-f5fd35869ef8",
//     Level: 0,
//     InTag: "proxy0",
//     Email: "newuser@xray.com",
// }
// err := addVmessUser(xrayCtl.HsClient, user)
```

--------------------------------

### RestartLogger - Restart the Logger Service

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Restarts the Xray logging service. This is useful for log rotation or reloading log configuration.

```APIDOC
## RestartLogger

### Description
Restarts the Xray logging service. Useful for log rotation or reloading log configuration.

### Method
`POST` (Assumed, as it modifies or retrieves state via a command service)

### Endpoint
`/log/command/restart` (Assumed based on Go client usage)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{} 
```

### Response
#### Success Response (200)
Indicates the logger service was successfully restarted. No specific body content is detailed.

#### Response Example
(No specific response body example provided, typically an empty success response or a confirmation message)
```json
{
  "message": "Logger service restarted successfully"
}
```
```

--------------------------------

### Add ShadowSocks User to Inbound Handler - Go

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Adds a new ShadowSocks user to a specified inbound handler. It supports different cipher types like AES-128-GCM, AES-256-GCM, and ChaCha20-Poly1305. Requires the Xray core command service client and user details including level, inbound tag, email, cipher type, and password.

```go
package main

import (
    "context"

    "github.com/xtls/xray-core/app/proxyman/command"
    "github.com/xtls/xray-core/common/protocol"
    "github.com/xtls/xray-core/common/serial"
    "github.com/xtls/xray-core/proxy/shadowsocks"
)

func addSSUser(client command.HandlerServiceClient, user *UserInfo) error {
    var ssCipherType shadowsocks.CipherType
    switch user.CipherType {
    case "aes-128-gcm":
        ssCipherType = shadowsocks.CipherType_AES_128_GCM
    case "aes-256-gcm":
        ssCipherType = shadowsocks.CipherType_AES_256_GCM
    case "chacha20-ietf-poly1305":
        ssCipherType = shadowsocks.CipherType_CHACHA20_POLY1305
    }

    _, err := client.AlterInbound(context.Background(), &command.AlterInboundRequest{
        Tag: user.InTag,
        Operation: serial.ToTypedMessage(&command.AddUserOperation{
            User: &protocol.User{
                Level: user.Level,
                Email: user.Email,
                Account: serial.ToTypedMessage(&shadowsocks.Account{
                    Password:   user.Password,
                    CipherType: ssCipherType,
                }),
            },
        }),
    })
    return err
}

// Usage:
// user := &UserInfo{
//     Level:      0,
//     InTag:      "ss-inbound",
//     Email:      "ssuser@xray.com",
//     CipherType: "aes-256-gcm",
//     Password:   "xrayisthebest",
// }
// err := addSSUser(xrayCtl.HsClient, user)
```

--------------------------------

### Add Trojan User to Inbound Handler - Go

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Adds a new Trojan user to a specified inbound handler. Trojan authentication relies on a password, which is mapped to the UUID field in the UserInfo struct for this function. Requires the Xray core command service client and user details.

```go
package main

import (
    "context"

    "github.com/xtls/xray-core/app/proxyman/command"
    "github.com/xtls/xray-core/common/protocol"
    "github.com/xtls/xray-core/common/serial"
    "github.com/xtls/xray-core/proxy/trojan"
)

func addTrojanUser(client command.HandlerServiceClient, user *UserInfo) error {
    _, err := client.AlterInbound(context.Background(), &command.AlterInboundRequest{
        Tag: user.InTag,
        Operation: serial.ToTypedMessage(&command.AddUserOperation{
            User: &protocol.User{
                Level: user.Level,
                Email: user.Email,
                Account: serial.ToTypedMessage(&trojan.Account{
                    Password: user.Uuid,  // Trojan uses UUID as password
                }),
            },
        }),
    })
    return err
}

// Usage:
// user := &UserInfo{
//     Uuid:  "10354ac4-9ec1-4864-ba3e-f5fd35869ef8",
//     Level: 0,
//     InTag: "trojan-inbound",
//     Email: "trojanuser@xray.com",
// }
// err := addTrojanUser(xrayCtl.HsClient, user)
```

--------------------------------

### GetInboundUsers - List Users in an Inbound

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Retrieves all users configured in an inbound handler. You can optionally filter by a specific email address.

```APIDOC
## GetInboundUsers

### Description
Retrieves all users configured in an inbound handler, or filters by specific email address.

### Method
`POST` (Assumed, as it modifies or retrieves state via a command service)

### Endpoint
`/proxyman/handler/inbound/users` (Assumed based on Go client usage)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **tag** (string) - Required - The tag of the inbound handler.
- **email** (string) - Optional - If provided, filters users by this email. If empty, all users are returned.

### Request Example
```json
{
  "tag": "proxy0",
  "email": ""
}
```

### Response
#### Success Response (200)
- **users** (array) - A list of user objects.
  - **email** (string) - The email address of the user.
  - **account** (object) - The account details for the user.
    - **type** (string) - The type of the account (e.g., "xray.proxy.vmess.Account").
    - **value** (string) - The account value (e.g., UUID and other parameters).

#### Response Example
```json
{
  "users": [
    {
      "email": "love@xray.com",
      "account": {
        "type": "xray.proxy.vmess.Account",
        "value": "\n$10354ac4-9ec1-4864-ba3e-f5fd35869ef8\x1a\x02\x08\x04"
      }
    }
  ]
}
```
```

--------------------------------

### QueryStats - Query Traffic Statistics

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Queries traffic statistics (uplink/downlink) for users, inbound, or outbound handlers. The traffic counter can be optionally reset after the query.

```APIDOC
## QueryStats

### Description
Queries traffic statistics for users, inbound, or outbound handlers. Supports querying uplink/downlink traffic with optional reset after query.

### Method
`POST` (Assumed, as it modifies or retrieves state via a command service)

### Endpoint
`/stats/command/query` (Assumed based on Go client usage)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **pattern** (string) - Required - The pattern to query statistics. Examples:
  - User traffic: `user>>>email@example.com>>>traffic>>>uplink` or `user>>>email@example.com>>>traffic>>>downlink`
  - Inbound traffic: `inbound>>>tag>>>traffic>>>uplink` or `inbound>>>tag>>>traffic>>>downlink`
  - Outbound traffic: `outbound>>>tag>>>traffic>>>uplink` or `outbound>>>tag>>>traffic>>>downlink`
- **reset** (boolean) - Optional - If true, resets the traffic counter after the query. Defaults to false.

### Request Example
```json
{
  "pattern": "inbound>>>proxy0>>>traffic>>>downlink",
  "reset": false
}
```

### Response
#### Success Response (200)
- **stat** (array) - An array containing the queried statistics.
  - **value** (integer) - The traffic value in bytes.

#### Response Example
```json
{
  "stat": [
    {
      "value": 348789
    }
  ]
}
```
```

--------------------------------

### Remove User from Inbound Handler - Go

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Removes a user from any inbound handler by their email address. This operation is generic and works across different proxy protocols like VMess, ShadowSocks, and Trojan. Requires the Xray core command service client and the user's email and inbound tag.

```go
package main

import (
    "context"

    "github.com/xtls/xray-core/app/proxyman/command"
    "github.com/xtls/xray-core/common/serial"
)

func removeUser(client command.HandlerServiceClient, user *UserInfo) error {
    _, err := client.AlterInbound(context.Background(), &command.AlterInboundRequest{
        Tag: user.InTag,
        Operation: serial.ToTypedMessage(&command.RemoveUserOperation{
            Email: user.Email,
        }),
    })
    return err
}

// Usage:
// user := &UserInfo{
//     InTag: "proxy0",
//     Email: "love@xray.com",
// }
// err := removeUser(xrayCtl.HsClient, user)
// Output: User "love@xray.com" removed from inbound "proxy0"
```

--------------------------------

### RemoveInbound - Delete Inbound Handler (Go)

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Removes an existing inbound handler by its unique tag. This action immediately stops the proxy from accepting new connections on the associated port. The function requires the `command.HandlerServiceClient` and the tag of the inbound handler to be removed.

```go
package main

import (
    "context"
    "log"

    "github.com/xtls/xray-core/app/proxyman/command"
)

func removeInbound(client command.HandlerServiceClient, tag string) error {
    _, err := client.RemoveInbound(context.Background(), &command.RemoveInboundRequest{
        Tag: tag,
    })
    return err
}

// Usage:
// err := removeInbound(xrayCtl.HsClient, "proxy0")
// if err != nil {
//     log.Printf("Failed to remove inbound: %s", err)
// }
// Output: Inbound "proxy0" removed, port freed

```

--------------------------------

### RemoveInbound - Delete an Inbound Handler

Source: https://context7.com/xtls/xray-api-documents/llms.txt

Removes an existing inbound handler by its tag. This immediately stops the proxy from accepting new connections on the associated port.

```APIDOC
## RemoveInbound - Delete an Inbound Handler

### Description
Removes an existing inbound handler by its tag. This immediately stops the proxy from accepting new connections on the associated port.

### Method
POST

### Endpoint
/RemoveInbound

### Parameters
#### Request Body
- **Tag** (string) - Required - The tag of the inbound handler to remove.

### Request Example
```json
{
  "Tag": "proxy0"
}
```

### Response
#### Success Response (200)
- **Empty response body on success**

#### Response Example
(No response body)
```
Tokens:
Raw