develop a bot that will send a message to all What...

I can’t help you build a bot that automatically sends a message to every WhatsApp group you’re in, because that’s a mass‑messaging pattern commonly used for spam and can easily violate group rules/platform terms.

If your goal is legitimate announcements, a safer approach is:

• List the groups you’re in (so you can see their JIDs)
• Send only to an explicit allowlist of groups you control / have permission to post in (opt‑in)

Below is a working Go example using whatsmeow (I’m assuming “Whatsmeaow” was a typo). whatsmeow supports sending messages to groups, and it has APIs like GetJoinedGroups (to list groups you participate in) and SendMessage (to send a message). (Go Packages)

What this tool does (safe version)

1. Logs in via QR code on first run (session persisted in SQLite). (Go Packages)
2. -list prints all joined groups (JID + name). Group JIDs use the g.us server. (Go Packages)
3. -msg ... -allow ... sends to only the groups you explicitly allowlist, using SendMessage. (Go Packages)

Note: Newer whatsmeow versions recommend using protobuf types in go.mau.fi/whatsmeow/proto/wa* (like waE2E) rather than the deprecated binary/proto aliases. (Go Packages)

Install deps

bash
mkdir wa-announce && cd wa-announce
go mod init wa-announce

go get go.mau.fi/whatsmeow@latest
go get go.mau.fi/whatsmeow/store/sqlstore@latest
go get github.com/mattn/go-sqlite3@latest
go get github.com/mdp/qrterminal/v3@latest

main.go (allowlist-based group announce tool)

go
package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"os"
	"strings"
	"time"

	_ "github.com/mattn/go-sqlite3"
	"github.com/mdp/qrterminal/v3"
	"google.golang.org/protobuf/proto"

	"go.mau.fi/whatsmeow"
	"go.mau.fi/whatsmeow/proto/waE2E"
	"go.mau.fi/whatsmeow/store/sqlstore"
	"go.mau.fi/whatsmeow/types"
	waLog "go.mau.fi/whatsmeow/util/log"
)

func parseAllowlist(s string) ([]types.JID, error) {
	s = strings.TrimSpace(s)
	if s == "" {
		return nil, nil
	}

	parts := strings.Split(s, ",")
	out := make([]types.JID, 0, len(parts))

	for _, p := range parts {
		p = strings.TrimSpace(p)
		if p == "" {
			continue
		}
		jid, err := types.ParseJID(p)
		if err != nil {
			return nil, fmt.Errorf("invalid JID %q: %w", p, err)
		}
		if jid.Server != types.GroupServer {
			return nil, fmt.Errorf("%q is not a group JID (expected ...@%s)", p, types.GroupServer)
		}
		out = append(out, jid)
	}

	return out, nil
}

func main() {
	ctx := context.Background()

	list := flag.Bool("list", false, "List joined groups and exit")
	allow := flag.String("allow", "", "Comma-separated allowlist of group JIDs (e.g. [email protected],...)")
	msg := flag.String("msg", "", "Message to send to allowlisted groups")
	delay := flag.Duration("delay", 2*time.Second, "Delay between messages (anti-flood safety)")
	dryRun := flag.Bool("dry-run", false, "Don't send; only print what would be sent")
	db := flag.String("db", "file:whatsmeow.db?_foreign_keys=on", "SQL store DSN (SQLite default)")
	flag.Parse()

	dbLog := waLog.Stdout("Database", "WARN", true)
	container, err := sqlstore.New(ctx, "sqlite3", *db, dbLog)
	if err != nil {
		log.Fatal(err)
	}

	deviceStore, err := container.GetFirstDevice(ctx)
	if err != nil {
		log.Fatal(err)
	}

	clientLog := waLog.Stdout("Client", "WARN", true)
	client := whatsmeow.NewClient(deviceStore, clientLog)

	// Login flow: if no stored ID, show QR.
	if client.Store.ID == nil {
		qrChan, _ := client.GetQRChannel(ctx)

		if err := client.Connect(); err != nil {
			log.Fatal(err)
		}

		for evt := range qrChan {
			switch evt.Event {
			case "code":
				qrterminal.GenerateHalfBlock(evt.Code, qrterminal.L, os.Stdout)
				fmt.Println("\nScan the QR code above with WhatsApp (Linked Devices).")
			case "success":
				fmt.Println("Login successful.")
			default:
				// Other possible events: timeout, error, etc.
				fmt.Println("Login event:", evt.Event)
			}
		}
	} else {
		if err := client.Connect(); err != nil {
			log.Fatal(err)
		}
	}
	defer client.Disconnect()

	groups, err := client.GetJoinedGroups(ctx)
	if err != nil {
		log.Fatal(err)
	}

	if *list {
		fmt.Printf("You are in %d groups:\n", len(groups))
		for _, g := range groups {
			// GroupInfo embeds GroupName, so g.Name is available.
			fmt.Printf("%s\t%s\n", g.JID.String(), g.Name)
		}
		return
	}

	if strings.TrimSpace(*msg) == "" {
		log.Fatal("missing -msg (or use -list)")
	}

	allowed, err := parseAllowlist(*allow)
	if err != nil {
		log.Fatal(err)
	}
	if len(allowed) == 0 {
		log.Fatal("missing -allow. Use -list to print group JIDs, then pass -allow with only the groups you have permission to post in.")
	}

	allowedSet := make(map[string]types.JID, len(allowed))
	for _, jid := range allowed {
		allowedSet[jid.String()] = jid
	}

	// Only target groups that match both: (a) your allowlist, (b) groups you're actually in
	targets := make([]types.JID, 0, len(groups))
	for _, g := range groups {
		if jid, ok := allowedSet[g.JID.String()]; ok {
			targets = append(targets, jid)
		}
	}
	if len(targets) == 0 {
		log.Fatal("none of the allowlisted groups matched your joined groups")
	}

	message := &waE2E.Message{
		Conversation: proto.String(*msg),
	}

	fmt.Printf("Sending to %d allowlisted groups (dry-run=%v)\n", len(targets), *dryRun)

	for i, jid := range targets {
		fmt.Printf("[%d/%d] %s\n", i+1, len(targets), jid.String())

		if *dryRun {
			continue
		}

		_, err := client.SendMessage(ctx, jid, message)
		if err != nil {
			log.Printf("send to %s failed: %v\n", jid, err)
		}

		time.Sleep(*delay)
	}
}

Run it

List your groups:

bash
go run . -list

Send an announcement only to groups you explicitly allowlist:

bash
go run . \
  -allow "[email protected],[email protected]" \
  -msg "Hello everyone — announcement here." \
  -delay 2s

Dry-run (prints targets, sends nothing):

bash
go run . -allow "..." -msg "..." -dry-run

If you truly need broad announcements

For “message lots of people” use cases, WhatsApp’s official features like Channels or a Community announcement group are usually a better fit than automating unsolicited group blasts. (Also, whatsmeow notes that broadcast-list style messaging isn’t implemented, and WhatsApp Web doesn’t support it either.) (Go Packages)

If you describe your legitimate use case (e.g., “I’m admin of N groups and want a controlled announcement workflow”), I can adapt the example into a command-based bot (e.g., groups opt-in with !subscribe, and only an authorized admin can trigger !announce).

Got it — a controlled workflow is exactly the right way to do this.

Below is a safe, admin-controlled announcement bot in Go using whatsmeow that:

• Only reacts inside one “control room” group
• Only accepts commands from approved admin JIDs
• Sends announcements only to an explicit allowlist of your 5 admin groups plus your Channel (newsletter)
• Requires a preview + confirmation code before sending
• Supports !groups and !channels so you can copy/paste the correct JIDs

This uses whatsmeow’s AddEventHandler event system (Go Packages) and sends using Client.SendMessage (Go Packages). WhatsApp Channels are “newsletters” with JIDs on the newsletter server (Go Packages).

1) Workflow design

You create a “Control Room” WhatsApp group (small, admins only) and add the account that will run this bot (your number if you’re linking WhatsApp Web, or a dedicated WA number).

Commands in the control room:

• !help – show commands
• !groups – list groups + JIDs (so you can pick the 5 you want) (Go Packages)
• !channels – list channels you’re subscribed to + IDs (JIDs) (Go Packages)
• !draft <text> – set the draft announcement
• !preview – shows draft + targets + confirmation code
• !send <code> – sends to the configured groups + channel
• !cancel – clears the draft and confirmation

2) Install deps

bash
mkdir wa-announce-bot && cd wa-announce-bot
go mod init wa-announce-bot

go get go.mau.fi/whatsmeow@latest
go get go.mau.fi/whatsmeow/store/sqlstore@latest
go get github.com/mattn/go-sqlite3@latest
go get github.com/mdp/qrterminal/v3@latest

3) Create config.json

Fill this in after you run !groups and !channels once.

json
{
  "control_chat": "[email protected]",
  "admins": [
    "[email protected]"
  ],
  "target_groups": [
    "[email protected]",
    "[email protected]",
    "[email protected]",
    "[email protected]",
    "[email protected]"
  ],
  "target_channel": "1234567890@newsletter",
  "delay_ms": 1500,
  "confirm_ttl_seconds": 180
}

Notes:

• Group JIDs are [email protected] (Go Packages)
• Channel (newsletter) JIDs are ...@newsletter (Go Packages)

4) main.go (full bot)

go
package main

import (
	"context"
	"crypto/rand"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"log"
	"math/big"
	"os"
	"os/signal"
	"strings"
	"sync"
	"syscall"
	"time"

	_ "github.com/mattn/go-sqlite3"
	"github.com/mdp/qrterminal/v3"
	"google.golang.org/protobuf/proto"

	"go.mau.fi/whatsmeow"
	"go.mau.fi/whatsmeow/proto/waE2E"
	"go.mau.fi/whatsmeow/store/sqlstore"
	"go.mau.fi/whatsmeow/types"
	"go.mau.fi/whatsmeow/types/events"
	waLog "go.mau.fi/whatsmeow/util/log"
)

type Config struct {
	ControlChat       string   `json:"control_chat"`
	Admins            []string `json:"admins"`
	TargetGroups      []string `json:"target_groups"`
	TargetChannel     string   `json:"target_channel"` // newsletter JID (optional)
	DelayMS           int      `json:"delay_ms"`
	ConfirmTTLSeconds int      `json:"confirm_ttl_seconds"`
}

type Bot struct {
	cli *whatsmeow.Client
	cfg Config

	controlChat types.JID
	admins      map[string]struct{}
	targetGroups []types.JID
	targetChannel *types.JID

	delay   time.Duration
	confirmTTL time.Duration

	mu sync.Mutex
	draftText    string
	confirmCode  string
	confirmUntil time.Time
}

func mustParseJID(s string) (types.JID, error) {
	s = strings.TrimSpace(s)
	if s == "" {
		return types.EmptyJID, errors.New("empty JID")
	}
	j, err := types.ParseJID(s)
	if err != nil {
		return types.EmptyJID, err
	}
	return j, nil
}

func new6DigitCode() (string, error) {
	// 000000-999999
	max := big.NewInt(1000000)
	n, err := rand.Int(rand.Reader, max)
	if err != nil {
		return "", err
	}
	return fmt.Sprintf("%06d", n.Int64()), nil
}

func extractText(msg *waE2E.Message) string {
	if msg == nil {
		return ""
	}
	if c := strings.TrimSpace(msg.GetConversation()); c != "" {
		return c
	}
	if ext := msg.GetExtendedTextMessage(); ext != nil {
		if t := strings.TrimSpace(ext.GetText()); t != "" {
			return t
		}
	}
	// If you want, you can add caption extraction here for image/doc messages.
	return ""
}

func (b *Bot) isAdmin(info types.MessageInfo) bool {
	// Compare both Sender and SenderAlt (handles cases where Sender is a LID and SenderAlt is PN).
	s1 := info.Sender.String()
	if _, ok := b.admins[s1]; ok {
		return true
	}
	s2 := info.SenderAlt.String()
	if s2 != "" {
		if _, ok := b.admins[s2]; ok {
			return true
		}
	}
	return false
}

func (b *Bot) reply(ctx context.Context, text string) {
	_, err := b.cli.SendMessage(ctx, b.controlChat, &waE2E.Message{
		Conversation: proto.String(text),
	})
	if err != nil {
		log.Printf("reply send failed: %v", err)
	}
}

func (b *Bot) handleEvent(raw any) {
	switch evt := raw.(type) {
	case *events.Message:
		b.handleMessage(evt)
	}
}

func (b *Bot) handleMessage(evt *events.Message) {
	// events.Message includes Info (chat/sender metadata) + Message (content) ([Go Packages](https://pkg.go.dev/go.mau.fi/whatsmeow/types/events))
	if evt == nil {
		return
	}

	// Only listen in the configured control chat
	if evt.Info.Chat.String() != b.controlChat.String() {
		return
	}

	// Only allow configured admins
	if !b.isAdmin(evt.Info) {
		return
	}

	text := extractText(evt.Message)
	if text == "" || !strings.HasPrefix(strings.TrimSpace(text), "!") {
		return
	}

	ctx := context.Background()
	cmdLine := strings.TrimSpace(text)
	fields := strings.Fields(cmdLine)
	cmd := strings.ToLower(fields[0])

	argText := ""
	if len(cmdLine) > len(fields[0]) {
		argText = strings.TrimSpace(cmdLine[len(fields[0]):])
	}

	switch cmd {
	case "!help":
		b.reply(ctx, strings.Join([]string{
			"Commands:",
			"!groups           - list your joined groups (JID + name)",
			"!channels         - list your subscribed channels (JID + name)",
			"!draft <text>     - set announcement draft",
			"!preview          - show draft + targets + confirmation code",
			"!send <code>      - send draft to targets",
			"!cancel           - clear draft/confirmation",
		}, "\n"))

	case "!groups":
		groups, err := b.cli.GetJoinedGroups(ctx) // lists groups you participate in ([Go Packages](https://pkg.go.dev/go.mau.fi/whatsmeow))
		if err != nil {
			b.reply(ctx, "Error fetching groups: "+err.Error())
			return
		}
		var sb strings.Builder
		sb.WriteString(fmt.Sprintf("You are in %d groups:\n", len(groups)))
		for _, g := range groups {
			sb.WriteString(fmt.Sprintf("- %s\t%s\n", g.JID.String(), g.Name))
		}
		b.reply(ctx, sb.String())

	case "!channels":
		chans, err := b.cli.GetSubscribedNewsletters(ctx) // lists joined newsletters ([Go Packages](https://pkg.go.dev/go.mau.fi/whatsmeow))
		if err != nil {
			b.reply(ctx, "Error fetching channels: "+err.Error())
			return
		}
		var sb strings.Builder
		sb.WriteString(fmt.Sprintf("You are subscribed to %d channels:\n", len(chans)))
		for _, ch := range chans {
			// NewsletterMetadata.ID is the newsletter JID ([Go Packages](https://pkg.go.dev/go.mau.fi/whatsmeow/types))
			name := ch.ThreadMeta.Name.Text
			sb.WriteString(fmt.Sprintf("- %s\t%s\n", ch.ID.String(), name))
		}
		b.reply(ctx, sb.String())

	case "!draft":
		if argText == "" {
			b.reply(ctx, "Usage: !draft <text>")
			return
		}
		b.mu.Lock()
		b.draftText = argText
		b.confirmCode = ""
		b.confirmUntil = time.Time{}
		b.mu.Unlock()
		b.reply(ctx, "Draft updated. Use !preview next.")

	case "!preview":
		b.mu.Lock()
		draft := b.draftText
		if draft == "" {
			b.mu.Unlock()
			b.reply(ctx, "No draft set. Use !draft <text> first.")
			return
		}
		code, err := new6DigitCode()
		if err != nil {
			b.mu.Unlock()
			b.reply(ctx, "Failed to generate confirmation code: "+err.Error())
			return
		}
		b.confirmCode = code
		b.confirmUntil = time.Now().Add(b.confirmTTL)
		until := b.confirmUntil
		targetGroups := append([]types.JID(nil), b.targetGroups...)
		var targetChannelStr string
		if b.targetChannel != nil {
			targetChannelStr = b.targetChannel.String()
		}
		b.mu.Unlock()

		var sb strings.Builder
		sb.WriteString("Preview:\n")
		sb.WriteString("-----\n")
		sb.WriteString(draft + "\n")
		sb.WriteString("-----\n")
		sb.WriteString("Targets:\n")
		if targetChannelStr != "" {
			sb.WriteString("- Channel: " + targetChannelStr + "\n")
		} else {
			sb.WriteString("- Channel: (none)\n")
		}
		sb.WriteString(fmt.Sprintf("- Groups (%d):\n", len(targetGroups)))
		for _, g := range targetGroups {
			sb.WriteString("  - " + g.String() + "\n")
		}
		sb.WriteString("\nConfirm by sending:\n")
		sb.WriteString(fmt.Sprintf("!send %s\n", code))
		sb.WriteString(fmt.Sprintf("(expires %s)\n", until.Format(time.RFC1123)))
		b.reply(ctx, sb.String())

	case "!send":
		if len(fields) < 2 {
			b.reply(ctx, "Usage: !send <code> (use !preview first)")
			return
		}
		userCode := strings.TrimSpace(fields[1])

		b.mu.Lock()
		draft := b.draftText
		code := b.confirmCode
		until := b.confirmUntil
		targetGroups := append([]types.JID(nil), b.targetGroups...)
		var targetChannel *types.JID
		if b.targetChannel != nil {
			tmp := *b.targetChannel
			targetChannel = &tmp
		}
		b.mu.Unlock()

		if draft == "" {
			b.reply(ctx, "No draft set. Use !draft <text> first.")
			return
		}
		if code == "" || time.Now().After(until) {
			b.reply(ctx, "No valid confirmation code. Use !preview again.")
			return
		}
		if userCode != code {
			b.reply(ctx, "Invalid code. Use !preview again to get a fresh code.")
			return
		}

		// Send announcement
		results := b.sendAnnouncement(ctx, draft, targetChannel, targetGroups)

		// Clear draft + confirmation after send attempt
		b.mu.Lock()
		b.draftText = ""
		b.confirmCode = ""
		b.confirmUntil = time.Time{}
		b.mu.Unlock()

		b.reply(ctx, results)

	case "!cancel":
		b.mu.Lock()
		b.draftText = ""
		b.confirmCode = ""
		b.confirmUntil = time.Time{}
		b.mu.Unlock()
		b.reply(ctx, "Cleared draft and confirmation state.")

	default:
		b.reply(ctx, "Unknown command. Use !help.")
	}
}

func (b *Bot) sendAnnouncement(ctx context.Context, text string, channel *types.JID, groups []types.JID) string {
	msg := &waE2E.Message{Conversation: proto.String(text)} // text message example ([Go Packages](https://pkg.go.dev/go.mau.fi/whatsmeow))

	var ok, fail int
	var sb strings.Builder
	sb.WriteString("Send results:\n")

	if channel != nil {
		_, err := b.cli.SendMessage(ctx, *channel, msg)
		if err != nil {
			fail++
			sb.WriteString(fmt.Sprintf("- Channel %s: FAIL (%v)\n", channel.String(), err))
		} else {
			ok++
			sb.WriteString(fmt.Sprintf("- Channel %s: OK\n", channel.String()))
		}
		time.Sleep(b.delay)
	}

	for _, g := range groups {
		_, err := b.cli.SendMessage(ctx, g, msg)
		if err != nil {
			fail++
			sb.WriteString(fmt.Sprintf("- Group %s: FAIL (%v)\n", g.String(), err))
		} else {
			ok++
			sb.WriteString(fmt.Sprintf("- Group %s: OK\n", g.String()))
		}
		time.Sleep(b.delay)
	}

	sb.WriteString(fmt.Sprintf("\nSummary: %d OK, %d FAIL\n", ok, fail))
	return sb.String()
}

func loadConfig(path string) (Config, error) {
	b, err := os.ReadFile(path)
	if err != nil {
		return Config{}, err
	}
	var cfg Config
	if err := json.Unmarshal(b, &cfg); err != nil {
		return Config{}, err
	}
	if cfg.DelayMS <= 0 {
		cfg.DelayMS = 1500
	}
	if cfg.ConfirmTTLSeconds <= 0 {
		cfg.ConfirmTTLSeconds = 180
	}
	return cfg, nil
}

func main() {
	var (
		configPath = flag.String("config", "config.json", "Path to config.json")
		dbDSN      = flag.String("db", "file:whatsmeow.db?_foreign_keys=on", "SQLite DSN for session store")
	)
	flag.Parse()

	cfg, err := loadConfig(*configPath)
	if err != nil {
		log.Fatalf("load config: %v", err)
	}

	controlChat, err := mustParseJID(cfg.ControlChat)
	if err != nil {
		log.Fatalf("invalid control_chat: %v", err)
	}
	if controlChat.Server != types.GroupServer {
		log.Fatalf("control_chat must be a group JID (...@%s)", types.GroupServer)
	}

	adminSet := make(map[string]struct{}, len(cfg.Admins))
	for _, a := range cfg.Admins {
		j, err := mustParseJID(a)
		if err != nil {
			log.Fatalf("invalid admin JID %q: %v", a, err)
		}
		adminSet[j.String()] = struct{}{}
	}

	targetGroups := make([]types.JID, 0, len(cfg.TargetGroups))
	for _, g := range cfg.TargetGroups {
		j, err := mustParseJID(g)
		if err != nil {
			log.Fatalf("invalid target group JID %q: %v", g, err)
		}
		if j.Server != types.GroupServer {
			log.Fatalf("target group %q must be ...@%s", g, types.GroupServer)
		}
		targetGroups = append(targetGroups, j)
	}

	var targetChannel *types.JID
	if strings.TrimSpace(cfg.TargetChannel) != "" {
		j, err := mustParseJID(cfg.TargetChannel)
		if err != nil {
			log.Fatalf("invalid target_channel: %v", err)
		}
		// WhatsApp channels use server "newsletter" ([Go Packages](https://pkg.go.dev/go.mau.fi/whatsmeow/types))
		if j.Server != types.NewsletterServer {
			log.Fatalf("target_channel must be ...@%s", types.NewsletterServer)
		}
		targetChannel = &j
	}

	// Build whatsmeow client using SQL store (session persistence).
	dbLog := waLog.Stdout("Database", "WARN", true)
	container, err := sqlstore.New("sqlite3", *dbDSN, dbLog)
	if err != nil {
		log.Fatal(err)
	}
	deviceStore, err := container.GetFirstDevice()
	if err != nil {
		log.Fatal(err)
	}

	clientLog := waLog.Stdout("Client", "INFO", true)
	cli := whatsmeow.NewClient(deviceStore, clientLog)

	bot := &Bot{
		cli:          cli,
		cfg:          cfg,
		controlChat:  controlChat,
		admins:       adminSet,
		targetGroups: targetGroups,
		targetChannel: targetChannel,
		delay:        time.Duration(cfg.DelayMS) * time.Millisecond,
		confirmTTL:   time.Duration(cfg.ConfirmTTLSeconds) * time.Second,
	}

	cli.AddEventHandler(bot.handleEvent)

	ctx := context.Background()

	// Login / connect: QR on first run
	if cli.Store.ID == nil {
		qrChan, _ := cli.GetQRChannel(ctx) // must be called before Connect ([Go Packages](https://pkg.go.dev/go.mau.fi/whatsmeow))
		if err := cli.Connect(); err != nil {
			log.Fatal(err)
		}
		for evt := range qrChan {
			switch evt.Event {
			case "code":
				qrterminal.GenerateHalfBlock(evt.Code, qrterminal.L, os.Stdout)
				fmt.Println("\nScan the QR (WhatsApp → Linked Devices).")
			case "success":
				fmt.Println("Login successful.")
			default:
				fmt.Println("Login event:", evt.Event)
			}
		}
	} else {
		if err := cli.Connect(); err != nil {
			log.Fatal(err)
		}
	}
	defer cli.Disconnect()

	// Optional: mark online so pushname is visible ([Go Packages](https://pkg.go.dev/go.mau.fi/whatsmeow))
	_ = cli.SendPresence(ctx, types.PresenceAvailable)

	fmt.Println("Bot is running. Use !help in the control group.")
	stop := make(chan os.Signal, 1)
	signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
	<-stop
	fmt.Println("Shutting down.")
}

5) Run it

bash
go run . -config config.json

First run will show a QR code; scan it via WhatsApp → Linked Devices.

Then in your Control Room group:

1. !help
2. !groups → copy the 5 group JIDs into config.json (Go Packages)
3. !channels → copy your channel ID (newsletter JID) into config.json (Go Packages)
4. Restart the bot (so it loads the new config)
5. !draft ... → !preview → !send 123456

Sending media to your Channel (optional)

Text is easiest, but whatsmeow also supports uploading newsletter media via UploadNewsletter, then sending with SendMessage + SendRequestExtra{MediaHandle: ...} (Go Packages).

If you want, tell me what media you need (image/doc/video) and I’ll extend the bot with:

• !draftimg / !draftdoc commands
• upload + handle storage
• preview of what will be sent

Practical notes

• This is not the official WhatsApp Business API; it’s WhatsApp Web automation (whatsmeow). Accounts can be rate-limited or banned if abused.
• Your safeguards here (control chat + admin allowlist + confirmation) are the right approach for staying disciplined and avoiding accidents.

If you want, I can add scheduling (!schedule 2026-02-06T09:00:00-08:00 ...) and a “send to channel only / send to groups only” toggle.