Batch Send Messages

curl -X POST "http://localhost:5001/message/sendbatch" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "header": {
        "no_persist": 0,
        "red_dot": 1,
        "sync_once": 0
      },
      "client_msg_no": "batch_msg_1",
      "from_uid": "system",
      "channel_id": "group123",
      "channel_type": 2,
      "expire": 0,
      "payload": "SGVsbG8gR3JvdXAgMQ==",
      "tag_key": "notification"
    },
    {
      "header": {
        "no_persist": 0,
        "red_dot": 1,
        "sync_once": 0
      },
      "client_msg_no": "batch_msg_2",
      "from_uid": "system",
      "channel_id": "group456",
      "channel_type": 2,
      "expire": 0,
      "payload": "SGVsbG8gR3JvdXAgMg==",
      "tag_key": "notification"
    }
  ]'

const messages = [
  {
    header: {
      no_persist: 0,
      red_dot: 1,
      sync_once: 0
    },
    client_msg_no: `batch_msg_${Date.now()}_1`,
    from_uid: "system",
    channel_id: "group123",
    channel_type: 2,
    expire: 0,
    payload: btoa(JSON.stringify({
      type: "text",
      content: "Hello Group 1"
    })),
    tag_key: "notification"
  },
  {
    header: {
      no_persist: 0,
      red_dot: 1,
      sync_once: 0
    },
    client_msg_no: `batch_msg_${Date.now()}_2`,
    from_uid: "system",
    channel_id: "group456",
    channel_type: 2,
    expire: 0,
    payload: btoa(JSON.stringify({
      type: "text",
      content: "Hello Group 2"
    })),
    tag_key: "notification"
  }
];

const response = await fetch('http://localhost:5001/message/sendbatch', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(messages)
});

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

import requests
import base64
import json

messages = [
    {
        "header": {
            "no_persist": 0,
            "red_dot": 1,
            "sync_once": 0
        },
        "client_msg_no": "batch_msg_1",
        "from_uid": "system",
        "channel_id": "group123",
        "channel_type": 2,
        "expire": 0,
        "payload": base64.b64encode(
            json.dumps({"type": "text", "content": "Hello Group 1"}).encode()
        ).decode(),
        "tag_key": "notification"
    },
    {
        "header": {
            "no_persist": 0,
            "red_dot": 1,
            "sync_once": 0
        },
        "client_msg_no": "batch_msg_2",
        "from_uid": "system",
        "channel_id": "group456",
        "channel_type": 2,
        "expire": 0,
        "payload": base64.b64encode(
            json.dumps({"type": "text", "content": "Hello Group 2"}).encode()
        ).decode(),
        "tag_key": "notification"
    }
]

response = requests.post('http://localhost:5001/message/sendbatch', json=messages)
result = response.json()
print(result)

package main

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

func main() {
    message1Content := map[string]interface{}{
        "type":    "text",
        "content": "Hello Group 1",
    }
    content1, _ := json.Marshal(message1Content)
    payload1 := base64.StdEncoding.EncodeToString(content1)
    
    message2Content := map[string]interface{}{
        "type":    "text",
        "content": "Hello Group 2",
    }
    content2, _ := json.Marshal(message2Content)
    payload2 := base64.StdEncoding.EncodeToString(content2)
    
    messages := []map[string]interface{}{
        {
            "header": map[string]interface{}{
                "no_persist": 0,
                "red_dot":    1,
                "sync_once":  0,
            },
            "client_msg_no": "batch_msg_1",
            "from_uid":      "system",
            "channel_id":    "group123",
            "channel_type":  2,
            "expire":        0,
            "payload":       payload1,
            "tag_key":       "notification",
        },
        {
            "header": map[string]interface{}{
                "no_persist": 0,
                "red_dot":    1,
                "sync_once":  0,
            },
            "client_msg_no": "batch_msg_2",
            "from_uid":      "system",
            "channel_id":    "group456",
            "channel_type":  2,
            "expire":        0,
            "payload":       payload2,
            "tag_key":       "notification",
        },
    }
    
    jsonData, _ := json.Marshal(messages)
    
    resp, err := http.Post(
        "http://localhost:5001/message/sendbatch",
        "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)
}

[
  {
    "message_id": 123456789,
    "message_seq": 1001,
    "client_msg_no": "batch_msg_1"
  },
  {
    "message_id": 123456790,
    "message_seq": 1002,
    "client_msg_no": "batch_msg_2"
  }
]

POST

message

sendbatch

curl -X POST "http://localhost:5001/message/sendbatch" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "header": {
        "no_persist": 0,
        "red_dot": 1,
        "sync_once": 0
      },
      "client_msg_no": "batch_msg_1",
      "from_uid": "system",
      "channel_id": "group123",
      "channel_type": 2,
      "expire": 0,
      "payload": "SGVsbG8gR3JvdXAgMQ==",
      "tag_key": "notification"
    },
    {
      "header": {
        "no_persist": 0,
        "red_dot": 1,
        "sync_once": 0
      },
      "client_msg_no": "batch_msg_2",
      "from_uid": "system",
      "channel_id": "group456",
      "channel_type": 2,
      "expire": 0,
      "payload": "SGVsbG8gR3JvdXAgMg==",
      "tag_key": "notification"
    }
  ]'

const messages = [
  {
    header: {
      no_persist: 0,
      red_dot: 1,
      sync_once: 0
    },
    client_msg_no: `batch_msg_${Date.now()}_1`,
    from_uid: "system",
    channel_id: "group123",
    channel_type: 2,
    expire: 0,
    payload: btoa(JSON.stringify({
      type: "text",
      content: "Hello Group 1"
    })),
    tag_key: "notification"
  },
  {
    header: {
      no_persist: 0,
      red_dot: 1,
      sync_once: 0
    },
    client_msg_no: `batch_msg_${Date.now()}_2`,
    from_uid: "system",
    channel_id: "group456",
    channel_type: 2,
    expire: 0,
    payload: btoa(JSON.stringify({
      type: "text",
      content: "Hello Group 2"
    })),
    tag_key: "notification"
  }
];

const response = await fetch('http://localhost:5001/message/sendbatch', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(messages)
});

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

import requests
import base64
import json

messages = [
    {
        "header": {
            "no_persist": 0,
            "red_dot": 1,
            "sync_once": 0
        },
        "client_msg_no": "batch_msg_1",
        "from_uid": "system",
        "channel_id": "group123",
        "channel_type": 2,
        "expire": 0,
        "payload": base64.b64encode(
            json.dumps({"type": "text", "content": "Hello Group 1"}).encode()
        ).decode(),
        "tag_key": "notification"
    },
    {
        "header": {
            "no_persist": 0,
            "red_dot": 1,
            "sync_once": 0
        },
        "client_msg_no": "batch_msg_2",
        "from_uid": "system",
        "channel_id": "group456",
        "channel_type": 2,
        "expire": 0,
        "payload": base64.b64encode(
            json.dumps({"type": "text", "content": "Hello Group 2"}).encode()
        ).decode(),
        "tag_key": "notification"
    }
]

response = requests.post('http://localhost:5001/message/sendbatch', json=messages)
result = response.json()
print(result)

package main

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

func main() {
    message1Content := map[string]interface{}{
        "type":    "text",
        "content": "Hello Group 1",
    }
    content1, _ := json.Marshal(message1Content)
    payload1 := base64.StdEncoding.EncodeToString(content1)
    
    message2Content := map[string]interface{}{
        "type":    "text",
        "content": "Hello Group 2",
    }
    content2, _ := json.Marshal(message2Content)
    payload2 := base64.StdEncoding.EncodeToString(content2)
    
    messages := []map[string]interface{}{
        {
            "header": map[string]interface{}{
                "no_persist": 0,
                "red_dot":    1,
                "sync_once":  0,
            },
            "client_msg_no": "batch_msg_1",
            "from_uid":      "system",
            "channel_id":    "group123",
            "channel_type":  2,
            "expire":        0,
            "payload":       payload1,
            "tag_key":       "notification",
        },
        {
            "header": map[string]interface{}{
                "no_persist": 0,
                "red_dot":    1,
                "sync_once":  0,
            },
            "client_msg_no": "batch_msg_2",
            "from_uid":      "system",
            "channel_id":    "group456",
            "channel_type":  2,
            "expire":        0,
            "payload":       payload2,
            "tag_key":       "notification",
        },
    }
    
    jsonData, _ := json.Marshal(messages)
    
    resp, err := http.Post(
        "http://localhost:5001/message/sendbatch",
        "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)
}

[
  {
    "message_id": 123456789,
    "message_seq": 1001,
    "client_msg_no": "batch_msg_1"
  },
  {
    "message_id": 123456790,
    "message_seq": 1002,
    "client_msg_no": "batch_msg_2"
  }
]

Overview

Send multiple messages in batch to improve message sending efficiency, suitable for group notifications, bulk push, and other scenarios.

Request Body

The request body is an array of message objects, each message object contains the following fields:

Required Parameters

string

required

Base64 encoded message content

string

required

Sender user ID

string

required

Target channel ID

integer

required

Channel type (1=personal channel, 2=group channel)

Optional Parameters

object

Message header information

Show header fields

integer

Whether to not persist message (0=persist, 1=do not persist)

integer

Whether to show red dot notification (0=do not show, 1=show)

integer

Whether it’s write diffusion, generally 0, only cmd messages are 1

string

Client message number

string

Stream message number

integer

Message expiration time (seconds), 0 means no expiration

array

Specified list of subscribers to receive the message

string

Subscriber user ID

curl -X POST "http://localhost:5001/message/sendbatch" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "header": {
        "no_persist": 0,
        "red_dot": 1,
        "sync_once": 0
      },
      "client_msg_no": "batch_msg_1",
      "from_uid": "system",
      "channel_id": "group123",
      "channel_type": 2,
      "expire": 0,
      "payload": "SGVsbG8gR3JvdXAgMQ==",
      "tag_key": "notification"
    },
    {
      "header": {
        "no_persist": 0,
        "red_dot": 1,
        "sync_once": 0
      },
      "client_msg_no": "batch_msg_2",
      "from_uid": "system",
      "channel_id": "group456",
      "channel_type": 2,
      "expire": 0,
      "payload": "SGVsbG8gR3JvdXAgMg==",
      "tag_key": "notification"
    }
  ]'

const messages = [
  {
    header: {
      no_persist: 0,
      red_dot: 1,
      sync_once: 0
    },
    client_msg_no: `batch_msg_${Date.now()}_1`,
    from_uid: "system",
    channel_id: "group123",
    channel_type: 2,
    expire: 0,
    payload: btoa(JSON.stringify({
      type: "text",
      content: "Hello Group 1"
    })),
    tag_key: "notification"
  },
  {
    header: {
      no_persist: 0,
      red_dot: 1,
      sync_once: 0
    },
    client_msg_no: `batch_msg_${Date.now()}_2`,
    from_uid: "system",
    channel_id: "group456",
    channel_type: 2,
    expire: 0,
    payload: btoa(JSON.stringify({
      type: "text",
      content: "Hello Group 2"
    })),
    tag_key: "notification"
  }
];

const response = await fetch('http://localhost:5001/message/sendbatch', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(messages)
});

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

import requests
import base64
import json

messages = [
    {
        "header": {
            "no_persist": 0,
            "red_dot": 1,
            "sync_once": 0
        },
        "client_msg_no": "batch_msg_1",
        "from_uid": "system",
        "channel_id": "group123",
        "channel_type": 2,
        "expire": 0,
        "payload": base64.b64encode(
            json.dumps({"type": "text", "content": "Hello Group 1"}).encode()
        ).decode(),
        "tag_key": "notification"
    },
    {
        "header": {
            "no_persist": 0,
            "red_dot": 1,
            "sync_once": 0
        },
        "client_msg_no": "batch_msg_2",
        "from_uid": "system",
        "channel_id": "group456",
        "channel_type": 2,
        "expire": 0,
        "payload": base64.b64encode(
            json.dumps({"type": "text", "content": "Hello Group 2"}).encode()
        ).decode(),
        "tag_key": "notification"
    }
]

response = requests.post('http://localhost:5001/message/sendbatch', json=messages)
result = response.json()
print(result)

package main

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

func main() {
    message1Content := map[string]interface{}{
        "type":    "text",
        "content": "Hello Group 1",
    }
    content1, _ := json.Marshal(message1Content)
    payload1 := base64.StdEncoding.EncodeToString(content1)
    
    message2Content := map[string]interface{}{
        "type":    "text",
        "content": "Hello Group 2",
    }
    content2, _ := json.Marshal(message2Content)
    payload2 := base64.StdEncoding.EncodeToString(content2)
    
    messages := []map[string]interface{}{
        {
            "header": map[string]interface{}{
                "no_persist": 0,
                "red_dot":    1,
                "sync_once":  0,
            },
            "client_msg_no": "batch_msg_1",
            "from_uid":      "system",
            "channel_id":    "group123",
            "channel_type":  2,
            "expire":        0,
            "payload":       payload1,
            "tag_key":       "notification",
        },
        {
            "header": map[string]interface{}{
                "no_persist": 0,
                "red_dot":    1,
                "sync_once":  0,
            },
            "client_msg_no": "batch_msg_2",
            "from_uid":      "system",
            "channel_id":    "group456",
            "channel_type":  2,
            "expire":        0,
            "payload":       payload2,
            "tag_key":       "notification",
        },
    }
    
    jsonData, _ := json.Marshal(messages)
    
    resp, err := http.Post(
        "http://localhost:5001/message/sendbatch",
        "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)
}

[
  {
    "message_id": 123456789,
    "message_seq": 1001,
    "client_msg_no": "batch_msg_1"
  },
  {
    "message_id": 123456790,
    "message_seq": 1002,
    "client_msg_no": "batch_msg_2"
  }
]

Response Fields

The response is an array, each element corresponds to a sent message:

integer

required

Server-generated message ID

integer

required

Message sequence number

string

required

Client message number (echo)

Status Codes

Status Code	Description
200	Batch messages sent successfully
400	Request parameter error
403	No sending permission
500	Internal server error

Use Cases

System Notifications

Announcement Push: Send system announcements to multiple groups
Activity Notifications: Batch send activity reminder messages
Maintenance Notifications: Batch notifications before system maintenance

Marketing Promotion

Promotional Messages: Send promotional information to target user groups
New Feature Introduction: Batch push new feature usage guides
User Surveys: Send questionnaire survey messages

Operations Management

Data Statistics: Batch send data reports
Task Assignment: Batch assign tasks to team members
Meeting Notifications: Batch send meeting invitations

Performance Optimization

Batch Size

Recommended Batch: Single batch sending should not exceed 100 messages
Batch Processing: Large volumes of messages can be sent in batches to avoid timeouts
Concurrency Control: Control the number of concurrent batch requests

Message Optimization

Content Compression: For identical content, use templates to reduce data transmission
Asynchronous Processing: Use asynchronous methods to handle batch sending
Error Retry: Implement retry mechanism for failed messages

Best Practices

Message Deduplication: Ensure each message’s client_msg_no is unique
Error Handling: Handle cases where some messages fail to send
Permission Verification: Verify sender’s sending permission for all target channels
Content Review: Review batch message content
Rate Limiting: Implement reasonable batch sending rate limits
Monitoring & Alerts: Monitor batch sending success rate and performance

Send Message Sync Channel Messages

Route Management

Message Management

Channel Management

User Management

Conversation Management

Connection Management

Event Management

Monitoring

System

Integration APIs

Administrator

Batch Send Messages

Overview

Request Body

Required Parameters

Optional Parameters

Response Fields

Status Codes

Use Cases

System Notifications

Marketing Promotion

Operations Management

Performance Optimization

Batch Size

Message Optimization

Best Practices

​Overview

​Request Body

​Required Parameters

​Optional Parameters

​Response Fields

​Status Codes

​Use Cases

​System Notifications

​Marketing Promotion

​Operations Management

​Performance Optimization

​Batch Size

​Message Optimization

​Best Practices

Overview

Request Body

Required Parameters

Optional Parameters

Response Fields

Status Codes

Use Cases

System Notifications

Marketing Promotion

Operations Management

Performance Optimization

Batch Size

Message Optimization

Best Practices