MessagesSendMultiMedia returns rpc error code 400: MEDIA_INVALID when sending multiple media in a single post

[asadbekGo]

I am trying to send multiple media files (e.g., images) in a single post using MessagesSendMultiMedia, but I keep getting the error:
rpc error code 400: MEDIA_INVALID

_, err = v1.tgBot.Client.API().MessagesSendMultiMedia(context.Background(), &tg.MessagesSendMultiMediaRequest{
Peer: &tg.InputPeerChat{ChatID: groupId},
MultiMedia: []tg.InputSingleMedia{
{
Media: &tg.InputMediaUploadedPhoto{File: inputFile},
RandomID: rand.Int63(),
Message: post.Text,
},
{
Media: &tg.InputMediaUploadedPhoto{File: inputFile},
RandomID: rand.Int63(),
},
},
})

What I Tried:

1. Verified that inputFile is correctly uploaded and contains valid ID, Parts, and MD5Checksum.
2. Ensured &inputFile is correctly assigned (also tried inputFile without pointer).
3. Tried InputMediaUploadedDocument instead of InputMediaUploadedPhoto (same error).
4. Attempted adding Flags: 1, but GroupedID is not available in InputSingleMedia.
   Questions:
5. How can I send multiple media files in a single post instead of separate messages?
6. Is there a way to properly group media items using MessagesSendMultiMedia?
7. Does InputSingleMedia support GroupedID, or is there another approach?
   Would appreciate any insights or suggestions. Thanks!

[asadbekGo]

@ernado

[borzovplus]

before using MessagesSendMultiMedia you should upload all files to telegram, please check docs before creating a issue https://core.telegram.org/methods

[asadbekGo]

@borzovplus I checked this and studied the documentation, but I still face the same problem. Have you tried using multiMedia yourself, if you know, can you please show me?

[borzovplus]

I can not to show, because I have a lot of abstractions (to much codes).
Try use "github.com/gotd/td/telegram/uploader" to upload Media before call MessagesSendMultiMedia, than create []tg.InputSingleMedia with uploaded medias

[asadbekGo]

func UploadFile(ctx context.Context, client *telegram.Client, filePath string) (tg.InputFileClass, []byte, error) {
file, err := os.Open(filePath)
if err != nil {
return nil, nil, fmt.Errorf("error opening file: %w", err)
}
defer file.Close()

fileInfo, err := file.Stat()
if err != nil {
	return nil, nil, fmt.Errorf("error getting file info: %w", err)
}

if fileInfo.Size() > maxFileSize {
	return nil, nil, fmt.Errorf("file size exceeds the limit of %d bytes", maxFileSize)
}

fileBytes, err := io.ReadAll(file)
if err != nil {
	return nil, nil, fmt.Errorf("error reading file: %w", err)
}

upl := uploader.NewUploader(client.API()).WithPartSize(uploader.MaximumPartSize)

f, err := upl.FromPath(context.Background(), filePath)
if err != nil {
	return nil, nil, fmt.Errorf("error creating uploader from path: %w", err)
}

return f, fileBytes, nil

}

@borzovplus Yes, I am using the same uploader package, but still no result.

[shampigeon]

Have you found a solution? @asadbekGo

[asadbekGo]

no, I still haven't found a solution. If you know a solution, please help @shampigeon

[asadbekGo]

please help @ernado

[meder111]

Привет @asadbekGo нашел решение ?

[asadbekGo]

@meder111 Привет, пока не нашел

[fauxlevin]

To make it work you should:
Step 1: Upload all media by calling MessagesUploadMedia() and use InputMediaUploadedPhoto type as media.
Step 2: Parse responses to build InputMediaPhoto type for every media
Step 3: Finally call MessagesSendMultiMedia and use InputMediaPhoto as a media type from step 2.

Looks like this, removed some error handling from the code.

multimedia := make([]tg.InputSingleMedia, 0, len(images))

for i := range images {
	resp, err := api.MessagesUploadMedia(ctx, &tg.MessagesUploadMediaRequest{
		Peer:  outputPeer,
		Media: &tg.InputMediaUploadedPhoto{
			File: images[i],
		},
	})
	mediaPhoto := resp.(*tg.MessageMediaPhoto)
	photo := mediaPhoto.Photo.(*tg.Photo)
	multimedia = append(multimedia, tg.InputSingleMedia{
		Media: &tg.InputMediaPhoto{
			ID: &tg.InputPhoto{
				ID:            photo.ID,
				AccessHash:    photo.AccessHash,
				FileReference: photo.FileReference,
			},
		},
		RandomID: rand.Int63()
	})
}
_, err := api.MessagesSendMultiMedia(ctx, &tg.MessagesSendMultiMediaRequest{
	Peer:       outputPeer,
	MultiMedia: multimedia,
})

Figured it out from this comment: alik0211/mtproto-core#148 (comment)

[expary]

For messages.sendMultiMedia, Telegram does not accept raw inputMediaUploaded* constructors directly in multi_media. The official docs now state this explicitly:

The medias to send: note that they must be separately uploaded using messages.uploadMedia first, using raw inputMediaUploaded* constructors is not supported.

Reference: https://core.telegram.org/method/messages.sendMultiMedia

So this will fail with MEDIA_INVALID:

tg.InputSingleMedia{
    Media: &tg.InputMediaUploadedPhoto{File: inputFile},
}

The media has to be uploaded/associated first, then converted to an InputMediaPhoto or InputMediaDocument and passed to messages.sendMultiMedia.

If you use the higher-level telegram/message helpers, gotd already handles this flow for uploaded photos/documents in album mode:

sender := message.NewSender(api).Resolve(peer)

_, err := sender.Album(ctx,
    message.UploadedPhoto(file1, message.Text("first caption")),
    message.UploadedPhoto(file2),
)

Internally, message.UploadedPhoto(...).applyMulti calls messages.uploadMedia, converts the returned MessageMediaPhoto into InputMediaPhoto, and then Album sends it through messages.sendMultiMedia.

If using the raw generated API, the flow should look like this:

media := make([]tg.InputSingleMedia, 0, len(files))

for _, file := range files {
    uploaded, err := api.MessagesUploadMedia(ctx, &tg.MessagesUploadMediaRequest{
        Peer: peer,
        Media: &tg.InputMediaUploadedPhoto{
            File: file,
        },
    })
    if err != nil {
        return err
    }

    photoMedia, ok := uploaded.(*tg.MessageMediaPhoto)
    if !ok {
        return fmt.Errorf("unexpected media type %T", uploaded)
    }
    photo, ok := photoMedia.Photo.AsNotEmpty()
    if !ok {
        return fmt.Errorf("unexpected empty photo")
    }

    media = append(media, tg.InputSingleMedia{
        Media: &tg.InputMediaPhoto{
            ID: photo.AsInput(),
        },
        RandomID: rand.Int63(),
    })
}

_, err := api.MessagesSendMultiMedia(ctx, &tg.MessagesSendMultiMediaRequest{
    Peer:       peer,
    MultiMedia: media,
})

No GroupedID is needed on InputSingleMedia; Telegram groups the items because they are sent in one messages.sendMultiMedia call.