Class TelegramClient

// this example assumes you've installed and imported the input package. npm i input.
// This package uses CLI to receive input from the user. you can use your own callback function.
import { TelegramClient } from "telegram";
import { StringSession } from "telegram/sessions";

const client = new TelegramClient(new StringSession(''), apiId, apiHash, {});
// logging in as a bot account
await client.start(botToken="123456:abcdfgh123456789);
// logging in as a user account
await client.start({
  phoneNumber: async () => await input.text("number ?"),
  password: async () => await input.text("password?"),
  phoneCode: async () => await input.text("Code ?"),
  onError: (err) => console.log(err),
});
>Number ? +1234567897
>Code ? 12345
>password ? 111111
Logged in as user...

You can now use the client instance to call other api requests.

await client.connect();
if (await client.checkAuthorization()){
    console.log("I am logged in!");
}else{
    console.log("I am connected to telegram servers but not logged in with any account/bot");
}

await client.connect();
// we should only use this when we are not already authorized.
// This function is very similar to `client.start`
// The minor difference that start checks if already authorized and supports bots as well.
if (!await client.checkAuthorization()){
    const phoneNumber = "+123456789";
    await client.signIn({
        apiId:132456,
        apiHash:"132456",
    },{
    phoneNumber: async () => await input.text("number ?"),
    password: async () => await input.text("password?"),
    phoneCode: async () => await input.text("Code ?"),
    onError: (err) => console.log(err),
    })
 }

'''ts await client.connect(); const user = await client.signInUserWithQrCode({ apiId, apiHash }, { onError: async function(p1: Error) { console.log("error", p1); // true = stop the authentication processes return true; }, qrCode: async (code) => { console.log("Convert the next string to a QR code and scan it"); console.log( tg://login?token=${code.token.toString("base64url")} ); }, password: async (hint) => { // password if needed return "1111"; } } ); console.log("user is", user);

'''

await client.connect();
const {phoneCodeHash,isCodeViaApp} = await client.sendCode({
    apiId:1234,
    apiHash:"123456789abcfghj",
},"+123456798"});

await client.connect();
const bot = await client.signInBot({
    apiId:1234,
    apiHash:"12345",
},{
    botToken:"123456:abcdfghae4fg654",
});
// we are now logged in as a bot
console.log("Logged in",bot);

this method can throw: "PASSWORD_HASH_INVALID" if you entered a wrong password (or set it to undefined). "EMAIL_INVALID" if the entered email is wrong "EMAIL_HASH_EXPIRED" if the user took too long to verify their email

// Makes the query to @pic
const results = await client.inlineQuery("pic", "something");
// clicks on the first result
await results[0].click();

import {Button} from "telegram/tl/custom/button";
 // PS this function is not async
const markup = client.buildReplyMarkup(Button.inline("Hello!"));

await client.sendMessage(chat, {
    message: "click me!",
    buttons: markup,
}

// The following example can also be used in a simpler way like so

await client.sendMessage(chat, {
    message: "click me!",
    buttons: [Button.inline("Hello!")],
}

const photo = message.photo;
const buffer = await client.downloadFile(
      new Api.InputPhotoFileLocation({
         id: photo.id,
         accessHash: photo.accessHash,
         fileReference: photo.fileReference,
         thumbSize: size.type
     }),
     {
         dcId: photo.dcId,
         fileSize: "m",
     }
);

const photo = message.photo;
for await (const chunk of client.iterDownload({
      file: new Api.InputPhotoFileLocation({
         id: photo.id,
         accessHash: photo.accessHash,
         fileReference: photo.fileReference,
         thumbSize: size.type
     }),
     offset: start,
     limit: end,
     requestSize:2048*1024
)){
    console.log("Downloaded chunk of size",chunk.length);
};

// Download your own profile photo
const buffer = await client.downloadProfilePhoto('me')
console.log("Downloaded image is",buffer);
// if you want to save it as a file you can use the fs module on node for that.
import { promises as fs } from 'fs';
await fs.writeFile("picture.jpg",buffer);

const buffer = await client.downloadMedia(message, {})
// to save it to a file later on using fs.
import { promises as fs } from 'fs';
await fs.writeFile("file",buffer);
// to use a progress callback you can pass it like so.
const buffer = await client.downloadMedia(message, {
    progressCallback : console.log
})

// sets the mode to HTML client.setParseMode("html"); await client.sendMessage("me",{message:"This is an underline text"}); // disable formatting client.setParseMode(undefined); await client.sendMessage("me",{message:" this will be sent as it is ** with no formatting **});

Telegram limits GetHistory requests every 10 requests (1 000 messages) therefore a sleep of 1 seconds will be the default for this limit.

Instances of custom Message

// From most-recent to oldest
for await (const message of client.iterMessages(chat,{}){
   console.log(message.id, message.text)
}

// From oldest to most-recent
for await (const message of client.iterMessages(chat,{reverse:true}){
   console.log(message.id, message.text)
}

// Filter by sender
for await (const message of client.iterMessages(chat,{fromUser:"me"}){
   console.log(message.id, message.text)
}

// Server-side search with fuzzy text
for await (const message of client.iterMessages(chat,{search:"hello"}){
   console.log(message.id, message.text)
}

// Filter by message type:
import { Api } from "telegram";
for await (const message of client.iterMessages(chat,{filter: Api.InputMessagesFilterPhotos}){
   console.log(message.id, message.photo)
}

// Getting comments from a post in a channel:
 * for await (const message of client.iterMessages(chat,{replyTo: 123}){
   console.log(message.chat.title,, message.text)
}

// The totalList has a .total attribute which will show the complete number of messages even if none are fetched.
// Get 0 photos and print the total to show how many photos there are
import { Api } from "telegram";
const photos = await client.getMessages(chat, {limit: 0, filter:Api.InputMessagesFilterPhotos})
console.log(photos.total)

// Get all the photos
const photos = await client.getMessages(chat, {limit: undefined, filter:Api.InputMessagesFilterPhotos})

// Get messages by ID:
const messages = await client.getMessages(chat, {ids:1337})
const message_1337 = messages[0];

// Markdown is the default.
await client.sendMessage("me",{message:"Hello **world!**});

// Defaults to another parse mode.
client.setParseMode("HTML");

await client.sendMessage('me', {message:'Some <b>bold</b> and <i>italic</i> text'})
await client.sendMessage('me', {message:'An <a href="https://example.com">URL</a>'})
await client.sendMessage('me', {message:'<a href="tg://user?id=me">Mentions</a>'})

// Explicit parse mode.
//  No parse mode by default
client.setParseMode(undefined);
//...but here I want markdown
await client.sendMessage('me', {message:'Hello, **world**!', {parseMode:"md"}})

// ...and here I need HTML
await client.sendMessage('me', {message:'Hello, <i>world</i>!', {parseMode='html'}})


// Scheduling a message to be sent after 5 minutes

await client.sendMessage(chat, {message:'Hi, future!', schedule:(60 * 5) + (Date.now() / 1000)})

// a single one
await client.forwardMessages(chat, {messages: message});
// or
await client.forwardMessages(chat, {messages:messageId,fromPeer:fromChat});
// or
await message.forwardTo(chat)

// multiple
await client.forwardMessages(chat, {messages:messages});
// or
await client.forwardMessages(chat,  {messages:messageIds,fromPeer:fromChat});

// Forwarding as a copy
await client.sendMessage(chat, {message:message});

MESSAGE_AUTHOR_REQUIRED if you're not the author of the message but tried editing it anyway. MESSAGE_NOT_MODIFIED if the contents of the message were not modified at all. MESSAGE_ID_INVALID if the ID of the message is invalid (the ID itself may be correct, but the message with that ID cannot be edited).
For example, when trying to edit messages with a reply markup (or clear markup) this error will be raised.

const message = await client.sendMessage(chat,{message:"Hi!"});

await client.editMessage(chat,{message:message,text:"Hello!"}
// or
await client.editMessage(chat,{message:message.id,text:"Hello!"}

This method does not validate that the message IDs belong to the chat that you passed! It's possible for the method to delete messages from different private chats and small group chats at once, so make sure to pass the right IDs.

await client.deleteMessages(chat, messages);

await client.deleteMessages(chat, messages, {revoke:false});

The default behavior is to not notify members, unlike the official applications.

const message = await client.sendMessage(chat, 'GramJS is awesome!');

await client.pinMessage(chat, message);

The default behavior is to not notify members, unlike the official applications.

const message = await client.sendMessage(chat, 'GramJS is awesome!');

// unpin one message
await client.unpinMessage(chat, message);

// unpin all messages
await client.unpinMessage(chat);

If neither message nor maximum ID are provided, all messages will be marked as read by assuming that max_id = 0.

// using a Message object
const message = await client.sendMessage(chat, 'GramJS is awesome!');
await client.markAsRead(chat, message)
// ...or using the int ID of a Message
await client.markAsRead(chat, message.id);

// ...or passing a list of messages to mark as read
await client.markAsRead(chat, messages)

instances of custom Dialog.

// logs all dialog IDs and their title.
for await (const dialog of client.iterDialogs({})){
    console.log(`${dialog.id}: ${dialog.title}`);
}

// Get all open conversation, print the title of the first
const dialogs = await client.getDialogs({});
const first = dialogs[0];
console.log(first.title);
<br/>
// Use the dialog somewhere else
await client.sendMessage(first, {message: "hi"});
<br/>
// Getting only non-archived dialogs (both equivalent)
non_archived = await client.get_dialogs({folder:0})
non_archived = await client.get_dialogs({archived:false})
<br/>
// Getting only archived dialogs (both equivalent)
archived = await client.get_dialogs({folder:1})
archived = await client.get_dialogs({archived:true})

The filter ChannelParticipantsBanned will return restricted users. If you want banned users you should use ChannelParticipantsKicked instead.

The User objects returned by GetParticipants with an additional .participant attribute
which is the matched ChannelParticipant type for channels/supergroup or ChatParticipants for normal chats.

// logs all user IDs in a chat.
for await (const user of client.iterParticipants(chat)){
    console.log("User id",user.id);
}

// Searches by name.
for await (const user of client.iterParticipants(chat, {search: "name"})){
    console.log("Username is ",user.username); // Some users don't have a username so this can be undefined.
}

// Filter by admins.
import { Api } from "telegram";

for await (const user of client.iterParticipants(chat, {filter:  Api.ChannelParticipantsAdmins})){
    console.log("admin first name is ",user.firstName);
}

import {TelegramClient} from "telegram";
import { NewMessage } from "telegram/events";
import { NewMessageEvent } from "telegram/events";
const client = new TelegramClient(new StringSession(''), apiId, apiHash, {});

async function handler(event: NewMessageEvent) {
...
}
client.addEventHandler(handler, new NewMessage({}));

generally it's better to use sendFile instead. This method returns a handle (an instance of InputFile or InputFileBig, as required) which can be later used before it expires (they are usable during less than a day).
Uploading a file will simply return a "handle" to the file stored remotely in the Telegram servers, which can be later used on. This will not upload the file to your own chat or any chat at all. This also can be used to update profile pictures

import { CustomFile } from "telegram/client/uploads";
const toUpload = new CustomFile("photo.jpg", fs.statSync("../photo.jpg").size, "../photo.jpg");
const file = await client.uploadFile({
 file: toUpload,
 workers: 1,
 });
 await client.invoke(new Api.photos.UploadProfilePhoto({
     file: file,
 }));

// Normal files like photos
await client.sendFile(chat, {file:'/my/photos/me.jpg', caption:"It's me!"})
// or
await client.sendMessage(chat, {message:"It's me!", file:'/my/photos/me.jpg'})

Voice notes or round videos
await client.sendFile(chat, {file: '/my/songs/song.mp3', voiceNote:True})
await client.sendFile(chat, {file: '/my/videos/video.mp4', videoNote:True})

// Custom thumbnails
await client.sendFile(chat, {file:'/my/documents/doc.txt', thumb:'photo.jpg'})

// Only documents
await client.sendFile(chat, {file:'/my/photos/photo.png', forceDocument:True})

//logging progress
await client.sendFile(chat, {file: file, progressCallback=console.log})

// Dices, including dart and other future emoji
await client.sendFile(chat, {file:new Api.InputMediaDice("")})
await client.sendFile(chat, {file:new Api.InputMediaDice("🎯")})

// Contacts
await client.sendFile(chat, {file: new Api.InputMediaContact({
 phoneNumber:'+1 123 456 789',
 firstName:'Example',
 lastName:'',
 vcard:''
 }))

const me = await client.getMe();
console.log("My username is",me.username);

if (await client.isBot()){
    console.log("I am a bot. PI is 3.14159265359);
} else {
    console.log("I am a human. Pies are delicious);
}

if (await client.isUserAuthorized()){ console.log("I am authorized. I can call functions and use requests"); }else{ console.log("I am not logged in. I need to sign in first before being able to call methods"); }

Telegram does not allow to get user profile by integer id if current client had never "saw" it.

const me = await client.getEntity("me");
console.log("My name is",utils.getDisplayName(me));

const chat = await client.getInputEntity("username");
for await (const message of client.iterMessages(chat){
    console.log("Message text is",message.text);
}

// Note that you could have used the username directly, but it's
// good to use getInputEntity if you will reuse it a lot.

// If you're going to use "username" often in your code
// (make a lot of calls), consider getting its input entity
// once, and then using the "user" everywhere instead.
user = await client.getInputEntity('username')

// The same applies to IDs, chats or channels.
chat = await client.getInputEntity(-123456789)

console.log(await client.getPeerId("me"));