Set Channel Blacklist

curl -X POST "http://localhost:5001/channel/blacklist_set" \
  -H "Content-Type: application/json" \
  -d '{
    "channel_id": "group123",
    "channel_type": 2,
    "uids": ["user1", "user2", "user3"]
  }'

curl -X POST "http://localhost:5001/channel/blacklist_set" \
  -H "Content-Type: application/json" \
  -d '{
    "channel_id": "group123",
    "channel_type": 2,
    "uids": []
  }'

// Set blacklist
const response = await fetch('http://localhost:5001/channel/blacklist_set', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    channel_id: 'group123',
    channel_type: 2,
    uids: ['user1', 'user2', 'user3']
  })
});

const data = await response.json();
console.log(data);

// Clear blacklist
const clearResponse = await fetch('http://localhost:5001/channel/blacklist_set', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    channel_id: 'group123',
    channel_type: 2,
    uids: []
  })
});

import requests

# Set blacklist
data = {
    "channel_id": "group123",
    "channel_type": 2,
    "uids": ["user1", "user2", "user3"]
}

response = requests.post('http://localhost:5001/channel/blacklist_set', json=data)
result = response.json()
print(result)

# Clear blacklist
clear_data = {
    "channel_id": "group123",
    "channel_type": 2,
    "uids": []
}

clear_response = requests.post('http://localhost:5001/channel/blacklist_set', json=clear_data)
clear_result = clear_response.json()
print(clear_result)

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    // Set blacklist
    data := map[string]interface{}{
        "channel_id":   "group123",
        "channel_type": 2,
        "uids":         []string{"user1", "user2", "user3"},
    }
    
    jsonData, _ := json.Marshal(data)
    
    resp, err := http.Post(
        "http://localhost:5001/channel/blacklist_set",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
    
    // Clear blacklist
    clearData := map[string]interface{}{
        "channel_id":   "group123",
        "channel_type": 2,
        "uids":         []string{},
    }
    
    clearJsonData, _ := json.Marshal(clearData)
    
    clearResp, err := http.Post(
        "http://localhost:5001/channel/blacklist_set",
        "application/json",
        bytes.NewBuffer(clearJsonData),
    )
    if err != nil {
        panic(err)
    }
    defer clearResp.Body.Close()
    
    var clearResult map[string]interface{}
    json.NewDecoder(clearResp.Body).Decode(&clearResult)
    fmt.Printf("%+v\n", clearResult)
}

{
  "status": "ok"
}

POST

channel

blacklist_set

curl -X POST "http://localhost:5001/channel/blacklist_set" \
  -H "Content-Type: application/json" \
  -d '{
    "channel_id": "group123",
    "channel_type": 2,
    "uids": ["user1", "user2", "user3"]
  }'

curl -X POST "http://localhost:5001/channel/blacklist_set" \
  -H "Content-Type: application/json" \
  -d '{
    "channel_id": "group123",
    "channel_type": 2,
    "uids": []
  }'

// Set blacklist
const response = await fetch('http://localhost:5001/channel/blacklist_set', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    channel_id: 'group123',
    channel_type: 2,
    uids: ['user1', 'user2', 'user3']
  })
});

const data = await response.json();
console.log(data);

// Clear blacklist
const clearResponse = await fetch('http://localhost:5001/channel/blacklist_set', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    channel_id: 'group123',
    channel_type: 2,
    uids: []
  })
});

import requests

# Set blacklist
data = {
    "channel_id": "group123",
    "channel_type": 2,
    "uids": ["user1", "user2", "user3"]
}

response = requests.post('http://localhost:5001/channel/blacklist_set', json=data)
result = response.json()
print(result)

# Clear blacklist
clear_data = {
    "channel_id": "group123",
    "channel_type": 2,
    "uids": []
}

clear_response = requests.post('http://localhost:5001/channel/blacklist_set', json=clear_data)
clear_result = clear_response.json()
print(clear_result)

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    // Set blacklist
    data := map[string]interface{}{
        "channel_id":   "group123",
        "channel_type": 2,
        "uids":         []string{"user1", "user2", "user3"},
    }
    
    jsonData, _ := json.Marshal(data)
    
    resp, err := http.Post(
        "http://localhost:5001/channel/blacklist_set",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
    
    // Clear blacklist
    clearData := map[string]interface{}{
        "channel_id":   "group123",
        "channel_type": 2,
        "uids":         []string{},
    }
    
    clearJsonData, _ := json.Marshal(clearData)
    
    clearResp, err := http.Post(
        "http://localhost:5001/channel/blacklist_set",
        "application/json",
        bytes.NewBuffer(clearJsonData),
    )
    if err != nil {
        panic(err)
    }
    defer clearResp.Body.Close()
    
    var clearResult map[string]interface{}
    json.NewDecoder(clearResp.Body).Decode(&clearResult)
    fmt.Printf("%+v\n", clearResult)
}

{
  "status": "ok"
}

Overview

Set (replace) the entire blacklist for a channel. This operation will first remove all existing blacklist entries and then add new ones. If UIDs is empty, the entire blacklist will be cleared.

Request Body

Required Parameters

string

required

Channel ID, cannot be empty or contain special characters

integer

required

Channel type

1 - Person channel
2 - Group channel

Optional Parameters

array

List of user IDs to set as blacklist. If empty, clears the entire blacklist.

string

User ID

curl -X POST "http://localhost:5001/channel/blacklist_set" \
  -H "Content-Type: application/json" \
  -d '{
    "channel_id": "group123",
    "channel_type": 2,
    "uids": ["user1", "user2", "user3"]
  }'

curl -X POST "http://localhost:5001/channel/blacklist_set" \
  -H "Content-Type: application/json" \
  -d '{
    "channel_id": "group123",
    "channel_type": 2,
    "uids": []
  }'

// Set blacklist
const response = await fetch('http://localhost:5001/channel/blacklist_set', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    channel_id: 'group123',
    channel_type: 2,
    uids: ['user1', 'user2', 'user3']
  })
});

const data = await response.json();
console.log(data);

// Clear blacklist
const clearResponse = await fetch('http://localhost:5001/channel/blacklist_set', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    channel_id: 'group123',
    channel_type: 2,
    uids: []
  })
});

import requests

# Set blacklist
data = {
    "channel_id": "group123",
    "channel_type": 2,
    "uids": ["user1", "user2", "user3"]
}

response = requests.post('http://localhost:5001/channel/blacklist_set', json=data)
result = response.json()
print(result)

# Clear blacklist
clear_data = {
    "channel_id": "group123",
    "channel_type": 2,
    "uids": []
}

clear_response = requests.post('http://localhost:5001/channel/blacklist_set', json=clear_data)
clear_result = clear_response.json()
print(clear_result)

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    // Set blacklist
    data := map[string]interface{}{
        "channel_id":   "group123",
        "channel_type": 2,
        "uids":         []string{"user1", "user2", "user3"},
    }
    
    jsonData, _ := json.Marshal(data)
    
    resp, err := http.Post(
        "http://localhost:5001/channel/blacklist_set",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
    
    // Clear blacklist
    clearData := map[string]interface{}{
        "channel_id":   "group123",
        "channel_type": 2,
        "uids":         []string{},
    }
    
    clearJsonData, _ := json.Marshal(clearData)
    
    clearResp, err := http.Post(
        "http://localhost:5001/channel/blacklist_set",
        "application/json",
        bytes.NewBuffer(clearJsonData),
    )
    if err != nil {
        panic(err)
    }
    defer clearResp.Body.Close()
    
    var clearResult map[string]interface{}
    json.NewDecoder(clearResp.Body).Decode(&clearResult)
    fmt.Printf("%+v\n", clearResult)
}

{
  "status": "ok"
}

Response Fields

string

required

Operation status, returns "ok" on success

Status Codes

Status Code	Description
200	Blacklist set successfully
400	Request parameter error
403	No management permission
404	Channel does not exist
500	Internal server error

Functionality

Set Operation

The set operation performs the following steps:

Clear Existing Blacklist: Remove all existing blacklist entries for the channel
Add New Entries: Add the provided user ID list to the blacklist
Delete Conversations: Automatically delete related conversations for blacklisted users
Update Permissions: Take effect immediately, blacklisted users cannot send or receive messages

Clear Operation

When uids is an empty array:

Clear all blacklist entries for the channel
Restore normal permissions for all users
Does not affect existing conversations

Blacklist Mechanism

Permission Restrictions

Blacklisted users are subject to the following restrictions:

Restriction	Description	Scope
Cannot Send Messages	Blocked from sending any messages to the channel	All message types
Cannot Receive Messages	Will not receive messages from the channel	All channel messages
Conversation Deletion	Related conversations are automatically deleted	Except live channels
Permission Revocation	Lose all channel-related permissions	Complete isolation

Special Cases

Live Channels: Do not process conversation deletion
Person Channels: Do not support blacklist operations
System Users: May have special permissions, not affected by blacklist

Use Cases

Batch Management

# Set new blacklist, replacing all existing entries
curl -X POST "/channel/blacklist_set" -d '{
  "channel_id": "group123",
  "channel_type": 2,
  "uids": ["spammer1", "spammer2", "violator1"]
}'

Clear Blacklist

# Clear all blacklist, restore all user permissions
curl -X POST "/channel/blacklist_set" -d '{
  "channel_id": "group123",
  "channel_type": 2,
  "uids": []
}'

Reset Blacklist

# Completely reset blacklist to new user list
curl -X POST "/channel/blacklist_set" -d '{
  "channel_id": "group123",
  "channel_type": 2,
  "uids": ["new_blocked_user"]
}'

Comparison with Other Blacklist Operations

Operation	Function	Use Case
`blacklist_add`	Add users to existing blacklist	Incrementally add violating users
`blacklist_set`	Replace entire blacklist	Batch management, reset blacklist
`blacklist_remove`	Remove specific users from blacklist	Lift restrictions on specific users

Best Practices

Use Carefully: Set operation clears all existing blacklist, ensure this is intended behavior
Backup Existing Data: Get current blacklist before setting as backup
Permission Verification: Ensure operator has sufficient management permissions
Log Recording: Record blacklist changes for auditing
Notification Mechanism: Consider notifying relevant administrators of blacklist changes
Test Validation: Thoroughly test before using in production environment

Error Handling

Common Errors

Error Message	Cause	Solution
Channel ID cannot be empty	No channel ID provided	Ensure valid channel ID is provided
Channel type cannot be 0	Invalid channel type	Use valid channel type (1 or 2)
Channel ID cannot contain special characters	Invalid channel ID format	Use alphanumeric characters and underscores
Remove all blacklist failed	Clear operation failed	Check channel status and permissions
Add blacklist failed	Add operation failed	Check user ID validity

Add Channel Blacklist - Incrementally add blacklist users
Remove Channel Blacklist - Remove specific blacklist users
Add Channel Whitelist - Manage whitelist users

Add Channel Blacklist Remove Channel Blacklist

Route Management

Message Management

Channel Management

User Management

Conversation Management

Connection Management

Event Management

Monitoring

System

Integration APIs

Administrator

Set Channel Blacklist

Overview

Request Body

Required Parameters

Optional Parameters

Response Fields

Status Codes

Functionality

Set Operation

Clear Operation

Blacklist Mechanism

Permission Restrictions

Special Cases

Use Cases

Batch Management

Clear Blacklist

Reset Blacklist

Comparison with Other Blacklist Operations

Best Practices

Error Handling

Common Errors

​Overview

​Request Body

​Required Parameters

​Optional Parameters

​Response Fields

​Status Codes

​Functionality

​Set Operation

​Clear Operation

​Blacklist Mechanism

​Permission Restrictions

​Special Cases

​Use Cases

​Batch Management

​Clear Blacklist

​Reset Blacklist

​Comparison with Other Blacklist Operations

​Best Practices

​Error Handling

​Common Errors

​Related APIs

Overview

Request Body

Required Parameters

Optional Parameters

Response Fields

Status Codes

Functionality

Set Operation

Clear Operation

Blacklist Mechanism

Permission Restrictions

Special Cases

Use Cases

Batch Management

Clear Blacklist

Reset Blacklist

Comparison with Other Blacklist Operations

Best Practices

Error Handling

Common Errors

Related APIs