# Telegram Multiple Account Mass Message Sender (`bhansalisoft/telegram-multiple-account-mass-message-sender`)

Telegram Multiple Account Mass Message Sender - is unique software for sending bulk message to telegram user using multiple telegram account.

- **URL**: https://beta-securitybyobscurity.apify.com/bhansalisoft/telegram-multiple-account-mass-message-sender.md
- **Developed by:** [bhansalisoft](https://beta-securitybyobscurity.apify.com/bhansalisoft) (community)
- **Categories:** Automation, Lead generation
- **Stats:** 62 total users, 5 monthly users, 100.0% runs succeeded, 10 bookmarks
- **User rating**: No ratings yet

## Pricing

$30.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.
You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

# README

### Telegram Multiple Account Mass Message Sender

Telegram Multiple Account Mass Message Sender - is unique software for sending bulk message to telegram user using multiple telegram account.

### Feature

➡️ software Support multiple Telegram account for send message

➡️ software will delay 60 second for every message send

➡️ User official telegram api for fetch

### How to use

➡️ Click on 'Try for free' button (You will get one day free)

### Generate AuthToken

➡️ Go to 'Input' tab and Fill all input field data

```
Telegram username - put telegram username list as array format (Example ["@user1", "@user2"])

Enter Your Text Message - Enter your custom message
```

➡️ Telegram Auth Token-   First Time you need to login via QR code , then after copy Auth Token and paste here so that no need to rescan again QR code.

```
    You can add multiple Auth Token from multiple telegram account and add as Array like

    ["Auth Token 1","Auth Token 2"]  
```

➡️ Click on 'Save and start' button

➡️ Go to 'log' tab to scan the QR code to authenticate the actor with telegram

➡️ Open telegram app on your device.

➡️ Go to Telegram menu -> Settings -> Devices and click on 'Add device' button and scan the QR code

➡️ After Successfull authentication, please copy Auth Token paste on Telegram Auth Token box as array format.\["Auth Token 1","Auth Token 2"]

➡️ Once you fill all your Auth Token of Telegram Accounts, press start , software will start sending message to telegram user list which you into Telegram username list box

https://youtu.be/U-e43nP51G8

if you face issue, you can email us at bhansalisoft781986@gmail.com

We provide Service for Scrap Telegram members and Messages from  Telegram Groups/Channel.  Charges : 50$ per 1000 Records.    contact us at bhansalisoft781986@gmail.com

Thanks

# Actor input Schema

## `USER_Name` (type: `array`):

Insert Telegram UserName where you want to send message

## `Message` (type: `array`):

Enter Your Message which you want to send

## `Daily_Add_Limit` (type: `string`):

Daily Add Limit will be usefull when you auto schedule this tool

## `Session_Token` (type: `array`):

After First time Login via qr code, You can copy Auth Token and paste here, then no need to re scan QR code

## Actor input object example

```json
{
  "Message": [
    "Test message 1",
    "Test message 2"
  ],
  "Daily_Add_Limit": "15"
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "Message": [
        "Test message 1",
        "Test message 2"
    ],
    "Daily_Add_Limit": "15"
};

// Run the Actor and wait for it to finish
const run = await client.actor("bhansalisoft/telegram-multiple-account-mass-message-sender").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "Message": [
        "Test message 1",
        "Test message 2",
    ],
    "Daily_Add_Limit": "15",
}

# Run the Actor and wait for it to finish
run = client.actor("bhansalisoft/telegram-multiple-account-mass-message-sender").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "Message": [
    "Test message 1",
    "Test message 2"
  ],
  "Daily_Add_Limit": "15"
}' |
apify call bhansalisoft/telegram-multiple-account-mass-message-sender --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bhansalisoft/telegram-multiple-account-mass-message-sender",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Multiple Account Mass Message Sender",
        "description": "Telegram Multiple Account Mass Message Sender - is unique software for sending bulk message to telegram user using multiple telegram account.",
        "version": "0.0",
        "x-build-id": "r6wk7E5qWCxIyxFNc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bhansalisoft~telegram-multiple-account-mass-message-sender/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bhansalisoft-telegram-multiple-account-mass-message-sender",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/bhansalisoft~telegram-multiple-account-mass-message-sender/runs": {
            "post": {
                "operationId": "runs-sync-bhansalisoft-telegram-multiple-account-mass-message-sender",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/bhansalisoft~telegram-multiple-account-mass-message-sender/run-sync": {
            "post": {
                "operationId": "run-sync-bhansalisoft-telegram-multiple-account-mass-message-sender",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "USER_Name",
                    "Message"
                ],
                "properties": {
                    "USER_Name": {
                        "title": "Telegram username",
                        "type": "array",
                        "description": "Insert Telegram UserName where you want to send message"
                    },
                    "Message": {
                        "title": "Enter Your Message List(We will select rendom message from list)  ",
                        "type": "array",
                        "description": "Enter Your Message which you want to send"
                    },
                    "Daily_Add_Limit": {
                        "title": "Daily Add Limit",
                        "type": "string",
                        "description": "Daily Add Limit will be usefull when you auto schedule this tool"
                    },
                    "Session_Token": {
                        "title": "Telegram Session Auth Token(Remain blank ,You will get after first time run this actor . after scran qr code you will get Auth Token)",
                        "type": "array",
                        "description": "After First time Login via qr code, You can copy Auth Token and paste here, then no need to re scan QR code"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
