Cant unmute member by ctx.api.restrictChatMember

[AnLaVN]

I am trying to make a bot to manage telegram channel, in which there is mute and unmute command to limit member, mute member can be done very easily with just command

ctx.api.restrictChatMember(ctx.chat.id, target.id, { permissions: { can_send_messages: false }});

But when i try to unmute member then the following command does not work

ctx.api.restrictChatMember(ctx.chat.id, target.id, { permissions: { can_send_messages: true }});

I have tried many variations of the command to try to unmute the member but none of them work

// With full permision, until_date = 0 but still not work
ctx.api.restrictChatMember(ctx.chat.id, target.id, { until_date: 0, permissions: {
	can_send_messages: true,
	can_send_media_messages: true,
	can_send_polls: true,
	can_send_other_messages: true,
	can_add_web_page_previews: true,
	can_change_info: false,
	can_invite_users: true,
	can_pin_messages: false,
	can_manage_topics: false
}});

I made sure that all chat.id and target.id fields are valid, as they still mute the member
My current temporary solution for this is to call telegram api directly to unmute member,

const unmute_member_http = async (chat_id, user_id) => {
	const params = new URLSearchParams({
		chat_id, user_id,
		permissions: JSON.stringify({
			can_send_messages: true
		}),
	}).toString();
	return fetch(`https://api.telegram.org/bot${config.bot_token}/restrictChatMember?${params}`, {
		method: "GET"
	}).then(r => r.json());
}

but I still want a clean, neat solution that works in grammy

[KnorpelSenf]

I assume that you actually passed true for all fields, rather than passing false for some? Also, your HTTP version effective does not fully lift all restrictions, it only allows sending messages again. I will assume that you simply omitted these fields here before posting your code.

grammY does not implement any logic around this method. It just directly passes the values to fetch the same way you do.

Look:

grammY/src/core/api.ts

Line 1073 in 5740197

return this.raw.restrictChatMember(

Can you provide a custom fetch function to grammY (via https://grammy.dev/ref/core/apiclientoptions#fetch) and then log the fetch parameters and post the output here? This might help during debugging.

[AnLaVN]

In telegram's official documentation https://core.telegram.org/bots/api#restrictchatmember they require the permissions field to be A JSON-serialized

I'm afraid that not implementing JSON.stringify logic might be confusing.

By the way here is grammy's debug code and log when calling mute member

const bot = new Bot(TOKEN, {
    client: {
        fetch: async (url, options) => {
            console.log("=== TELEGRAM FETCH ===");
            console.log("URL:", url.toString());
            console.log("OPTIONS:", options);
            const res = await fetch(url, options);
            console.log("=== TELEGRAM RESPONSE ===");
            console.log(res.status, res.statusText);
            return res;
        }
    }
});

Log when mute member

=== TELEGRAM FETCH ===
URL: https://api.telegram.org/botHIDDENCONTENT/restrictChatMember
OPTIONS: {
  compress: true,
  agent: Agent {
    _events: [Object: null prototype] {
      free: [Function (anonymous)],
      newListener: [Function: maybeEnableKeylog]
    },
    _eventsCount: 2,
    _maxListeners: undefined,
    defaultPort: 443,
    protocol: 'https:',
    options: [Object: null prototype] {
      keepAlive: true,
      noDelay: true,
      path: null
    },
    requests: [Object: null prototype] {},
    sockets: [Object: null prototype] {},
    freeSockets: [Object: null prototype] {},
    keepAliveMsecs: 1000,
    keepAlive: true,
    maxSockets: Infinity,
    maxFreeSockets: 256,
    scheduling: 'lifo',
    maxTotalSockets: Infinity,
    totalSocketCount: 0,
    maxCachedSessions: 100,
    _sessionCache: { map: {}, list: [] },
    [Symbol(shapeMode)]: false,
    [Symbol(kCapture)]: false
  },
  signal: AbortSignal {},
  method: 'POST',
  headers: { 'content-type': 'application/json', connection: 'keep-alive' },
  body: '{"chat_id":-HIDDENCONTENT,"user_id":HIDDENCONTENT,"permissions":{"until_date":1764947941,"permissions":{"can_send_messages":false,"can_send_media_messages":false,"can_send_polls":false,"can_send_other_messages":false,"can_add_web_page_previews":false,"can_change_info":false,"can_invite_users":false,"can_pin_messages":false,"can_manage_topics":false}}}'
}
=== TELEGRAM RESPONSE ===
200 OK

Log when unmute member

=== TELEGRAM FETCH ===
URL: https://api.telegram.org/botHIDDENCONTENT/restrictChatMember
OPTIONS: {
  compress: true,
  agent: Agent {
    _events: [Object: null prototype] {
      free: [Function (anonymous)],
      newListener: [Function: maybeEnableKeylog]
    },
    _eventsCount: 2,
    _maxListeners: undefined,
    defaultPort: 443,
    protocol: 'https:',
    options: [Object: null prototype] {
      keepAlive: true,
      noDelay: true,
      path: null
    },
    requests: [Object: null prototype] {},
    sockets: [Object: null prototype] {},
    freeSockets: [Object: null prototype] {},
    keepAliveMsecs: 1000,
    keepAlive: true,
    maxSockets: Infinity,
    maxFreeSockets: 256,
    scheduling: 'lifo',
    maxTotalSockets: Infinity,
    totalSocketCount: 0,
    maxCachedSessions: 100,
    _sessionCache: { map: {}, list: [] },
    [Symbol(shapeMode)]: false,
    [Symbol(kCapture)]: false
  },
  signal: AbortSignal {},
  method: 'POST',
  headers: { 'content-type': 'application/json', connection: 'keep-alive' },
  body: '{"chat_id":-HIDDENCONTENT,"user_id":HIDDENCONTENT,"permissions":{"until_date":0,"permissions":{"can_send_messages":true,"can_send_media_messages":true,"can_send_polls":true,"can_send_other_messages":true,"can_add_web_page_previews":true,"can_change_info":false,"can_invite_users":true,"can_pin_messages":false,"can_manage_topics":false}}}'
}

I hope the team has sample code for this case so I can use it more correctly

[KnorpelSenf]

The repeated JSON serialisation isn't needed. This isn't related to the issue.

I see that you tried to unmute a user by passing the following payload:

{
  "chat_id": -HIDDENCONTENT,
  "user_id": HIDDENCONTENT,
  "permissions": {
    "until_date": 0,
    "permissions": {
      "can_send_messages": true,
      "can_send_media_messages": true,
      "can_send_polls": true,
      "can_send_other_messages": true,
      "can_add_web_page_previews": true,
      "can_change_info": false,
      "can_invite_users": true,
      "can_pin_messages": false,
      "can_manage_topics": false
    }
  }
}

Note the following sentence from the docs you linked to:

Pass True for all permissions to lift restrictions from a user.

You didn't do that. You passed false for some permissions. This likely explains why an unmute doesn't take place.

[AnLaVN]

Even pass True for all permissions

=== TELEGRAM FETCH ===
URL: https://api.telegram.org/botHIDDENCONTENT/restrictChatMember
OPTIONS: {
  compress: true,
  agent: Agent {
    _events: [Object: null prototype] {
      free: [Function (anonymous)],
      newListener: [Function: maybeEnableKeylog]
    },
    _eventsCount: 2,
    _maxListeners: undefined,
    defaultPort: 443,
    protocol: 'https:',
    options: [Object: null prototype] {
      keepAlive: true,
      noDelay: true,
      path: null
    },
    requests: [Object: null prototype] {},
    sockets: [Object: null prototype] {},
    freeSockets: [Object: null prototype] {},
    keepAliveMsecs: 1000,
    keepAlive: true,
    maxSockets: Infinity,
    maxFreeSockets: 256,
    scheduling: 'lifo',
    maxTotalSockets: Infinity,
    totalSocketCount: 0,
    maxCachedSessions: 100,
    _sessionCache: { map: {}, list: [] },
    [Symbol(shapeMode)]: false,
    [Symbol(kCapture)]: false
  },
  signal: AbortSignal {},
  method: 'POST',
  headers: { 'content-type': 'application/json', connection: 'keep-alive' },
  body: '{"chat_id":-HIDDENCONTENT,"user_id":"HIDDENCONTENT","permissions":{"until_date":0,"permissions":{"can_send_messages":true,"can_send_media_messages":true,"can_send_polls":true,"can_send_other_messages":true,"can_add_web_page_previews":true,"can_change_info":true,"can_invite_users":true,"can_pin_messages":true,"can_manage_topics":true}}}'
}
=== TELEGRAM RESPONSE ===
200 OK

or the until_date field is removed

body: '{"chat_id":-1003375184961,"user_id":"1460020747","permissions":{"permissions":{"can_send_messages":true,"can_send_media_messages":true,"can_send_polls":true,"can_send_other_messages":true,"can_add_web_page_previews":true,"can_change_info":true,"can_invite_users":true,"can_pin_messages":true,"can_manage_topics":true}}}'

then the member still will not his rights restored.

how can i unmute they in right way ??? :(((

one more thing is that mute function also doesn't work as expected when until_date field doesn't remove itself when time is over

const until_date = Math.floor(Date.now() / 1000) + 1 * 3600; // mute to 1h
const permissions_on_mute = {
	can_send_messages: false,
	can_send_media_messages: false,
	can_send_polls: false,
	can_send_other_messages: false,
	can_add_web_page_previews: false,
	can_change_info: false,
	can_invite_users: false,
	can_pin_messages: false,
	can_manage_topics: false
};
ctx.api.restrictChatMember(ctx.chat.id, user_id, { until_date, permissions: permissions_on_mute });

[AnLaVN]

The manual api call solution is still the most effective, this will be the solution I use while waiting for grammY to work

const until_date = Math.floor(Date.now() / 1000) + config.time_mute * 3600; // mute in X hours
const mute_member_http = async (chat_id, user_id, until_date) => {
	const params = new URLSearchParams({
		chat_id, user_id,
		permissions: JSON.stringify({ can_send_messages: false }),
		until_date
	}).toString();
	return fetch(`https://api.telegram.org/bot${config.bot_token}/restrictChatMember?${params}`, {
		method: "GET"
	}).then(r => r.json());
}
const unmute_member_http = async (chat_id, user_id) => {
	const params = new URLSearchParams({
		chat_id, user_id,
		permissions: JSON.stringify({ can_send_messages: true }),
	}).toString();
	return fetch(`https://api.telegram.org/bot${config.bot_token}/restrictChatMember?${params}`, {
		method: "GET"
	}).then(r => r.json());
}

[KnorpelSenf]

The fetch call is a vastly different operation than the API call via grammY. If you do different things, it is expected that you have different outcomes.

It doesn't make sense to wait for grammY in any way. There is no logic in grammY that could be fixed, so nothing can happen here. Either adjust your grammY code, or keep using fetch directly. If you need help, you'll need to provide more info (such as two code examples that actually perform the same call with and without grammY).

[KnorpelSenf]

Closing due to a lack of response. Probably solved?