Whatsapp Gateway | Multi Device v7.0.0 NULLED

bloserda · June 27

14 hours ago, Magd Almuntaser said:

@Mahmoud @Gusik Prasetyo @Enno Askrindo @bloserda

Thank you handsome!

Its decode all file js and php?

Magd Almuntaser · June 28

7 hours ago, bloserda said:

Thank you handsome!

Its decode all file js and php?

No it's only php .. the js file need some time to decoding and testing

So i will decode the js files this week

pak kacung · June 28

List message kok belum bisa ya untuk v7? Caranya gimana?

wahyou · June 28

@pak kacung di android bisa bro

pak kacung · June 28

Apa yg harus diseting?

pak kacung · June 28

Yang terhubung dengan aplikasi harus whatsapp busnis apa juga termasuk sebagai penerimanya?

Magd Almuntaser · June 28

5 hours ago, pak kacung said:

List message kok belum bisa ya untuk v7? Caranya gimana?

Kamu tidak bisa melakukannya, daftar pesan (message list) hanya berfungsi di web dan iOS, bukan di Android karena aplikasi WhatsApp Business.

5 hours ago, wahyou said:

@pak kacung di android bisa bro

Iya, seperti yang dikatakan oleh Wahyou, hanya di WhatsApp Business.

pak kacung · June 28

List message Ternyata sudah jalan, dan bisa di whatsapp bussines maupun official

utm · June 29

@Fud

On 6/27/2024 at 8:08 PM, Fud said:

Help me in aapanel QR code does not appear

Here is the setup to install wamd if you're using aapanel.

1. Add php project site in website menu.

2. Install pm2 manager in app store, install node (if not yet), add project and set to the directory project then set port 3100 (make sure port 3100 is listening, you can add and check in security menu)

3. Add node project in website menu, example like this

4. IMPORTANT THING, don't activate the SSL in your website. if already installed, disabled it. because it will not work if you're using SSL

5. Install project like usual by go to project_url/install

6. after installation complete, login then go to setting server menu. then setting like this

* you don't need include port (:3100) in the url

7. Add device and try scan, it will work.

Fud · June 29

13 hours ago, utm said:

@Fud

Here is the setup to install wamd if you're using aapanel.

1. Add php project site in website menu.

2. Install pm2 manager in app store, install node (if not yet), add project and set to the directory project then set port 3100 (make sure port 3100 is listening, you can add and check in security menu)

3. Add node project in website menu, example like this

4. IMPORTANT THING, don't activate the SSL in your website. if already installed, disabled it. because it will not work if you're using SSL

5. Install project like usual by go to project_url/install

6. after installation complete, login then go to setting server menu. then setting like this

* you don't need include port (:3100) in the url

7. Add device and try scan, it will work.

Magd Almuntaser · June 29

56 minutes ago, Fud said:

yes just click on image and you will see it

Fud · June 29

6 hours ago, Magd Almuntaser said:

yes just click on image and you will see it

The Billionaire · June 30

On 6/28/2024 at 11:54 AM, wahyou said:

@pak kacung di android bisa bro

is this android???

pak kacung · June 30

On 6/28/2024 at 5:54 PM, wahyou said:

@pak kacung di android bisa bro

Iya....punya saya juga sudah bisa...apakah sudah bisa kirim list message via app scrip google?

On 6/28/2024 at 5:54 PM, wahyou said:

@pak kacung di android bisa bro

Iya....punya saya juga sudah bisa...apakah sudah bisa kirim list message via app scrip google?

pak kacung · June 30

3 hours ago, The Billionaire said:

is this android???

Iya betul demo disini +62 815-5955-4823

The Billionaire · June 30

Please who knows a trick I can use to send broadcast messages to 3k numbers without being banned ?????

Magd Almuntaser · Sunday at 09:44 PM

16 hours ago, The Billionaire said:

Please who knows a trick I can use to send broadcast messages to 3k numbers without being banned ?????

you can but not 3k numbers .. only 255 every broadcast .. you need to change some files to able to send to brodcast ..
whatsapp gateway script use lib (WhiskeySockets/Baileys) that can login, send msg .. etc
so you can go to here:

github_com/WhiskeySockets/Baileys/pull/249

i've decoded (server/whatsapp.js) file for you so you can change anything you want (Only for v7.0.0):

/**************************/
/*    Nulled & Decoded    */
/*   By Magd Almuntaser   */
/*         TTMTT          */
/*         7.0.0          */
/**************************/

const { Boom } = require('@hapi/boom')
const {
  default: makeWASocket,
  Browsers,
  fetchLatestBaileysVersion,
  useMultiFileAuthState,
  makeCacheableSignalKeyStore,
  DisconnectReason,
} = require('@whiskeysockets/baileys')
const QRCode = require('qrcode'),
  fs = require('fs')
let sock = [],
  qrcode = [],
  pairingCode = [],
  intervalStore = []
const { setStatus } = require('./database/index'),
  { IncomingMessage } = require('./controllers/incomingMessage'),
  {
    formatReceipt,
    getSavedPhoneNumber,
    prepareMediaMessage,
  } = require('./lib/helper'),
  MAIN_LOGGER = require('./lib/pino'),
  NodeCache = require('node-cache'),
  logger = MAIN_LOGGER.child({}),
  msgRetryCounterCache = new NodeCache(),
  connectToWhatsApp = async (
    token,
    ev = null,
    auth = false
  ) => {
    if (typeof qrcode[token] !== 'undefined' && !auth) {
      return (
        ev?.emit('qrcode', {
          token: token,
          data: qrcode[token],
          message: 'please scan with your Whatsapp Accountt',
        }),
        {
          status: false,
          sock: sock[token],
          qrcode: qrcode[token],
          message: 'please scan',
        }
      )
    }
    if (typeof pairingCode[token] !== 'undefined' && auth) {
      return (
        ev?.emit('code', {
          token: token,
          data: pairingCode[token],
          message:
            'Go to whatsapp -> link device -> link with phone number, and pairing with this code.',
        }),
        {
          status: false,
          code: pairingCode[token],
          message: 'pairing with that code',
        }
      )
    }
    try {
      let phoneNum = sock[token].user.id.split(':')
      phoneNum = phoneNum[0] + '@s.whatsapp.net'
      const ppUrl = await getPpUrl(token, phoneNum)
      return (
        ev?.emit('connection-open', {
          token: token,
          user: sock[token].user,
          ppUrl: ppUrl,
        }),
        delete qrcode[token],
        delete pairingCode[token],
        {
          status: true,
          message: 'Already connected',
        }
      )
    } catch (error) {
      ev?.emit('message', {
        token: token,
        message: 'Connecting.. (1)..',
      })
    }
    const { version: version, isLatest: isLatest } =
      await fetchLatestBaileysVersion()
    console.log(
      'You re using whatsapp gateway M Pedia v6.1.0 - Contact admin if any trouble : 6292298859671'
    )
    console.log('using WA v' + version.join('.') + ', isLatest: ' + isLatest)
    const { state: state, saveCreds: saveCreds } =
      await useMultiFileAuthState('./credentials/' + token)
    sock[token] = makeWASocket({
      version: version,
      browser: Browsers.macOS('Chrome', 'Mpedia'),
      logger: logger,
      printQRInTerminal: false,
      auth: {
        creds: state.creds,
        keys: makeCacheableSignalKeyStore(state.keys, logger),
      },
      msgRetryCounterCache: msgRetryCounterCache,
      generateHighQualityLinkPreview: true,
    })
    if (auth && 'me' in state.creds === false) {
      const phoneNumber = await getSavedPhoneNumber(token)
      try {
        const code = await sock[token].requestPairingCode(phoneNumber)
        pairingCode[token] = code
      } catch (error) {
        ev?.emit('message', {
          token: token,
          message: 'Time out, please refresh page',
        })
      }
      ev?.emit('code', {
        token: token,
        data: pairingCode[token],
        message:
          'Go to whatsapp -> link device -> link with phone number, and pairing with this code.',
      })
    }
    return (
      sock[token].ev.process(async (events) => {
        if (events['connection.update']) {
          const update = events['connection.update'],
            {
              connection: connection,
              lastDisconnect: lastDisconnect,
              qr: qr,
            } = update
          if (connection === 'close') {
            const proto = lastDisconnect.error?.output?.payload?.message,
              msgs = lastDisconnect.error?.output?.payload?.error
            if (
              (lastDisconnect?.error instanceof Boom)?.output?.statusCode !==
              DisconnectReason.loggedOut
            ) {
              delete qrcode[token]
              ev?.emit('message', {
                token: token,
                message: 'Connecting..',
              })
              if (proto == 'QR refs attempts ended') {
                sock[token].ws.close()
                delete qrcode[token]
                delete pairingCode[token]
                delete sock[token]
                ev?.emit('message', {
                  token: token,
                  message: 'Request QR ended. reload web to scan again',
                })
                return
              }
              ;(msgs === 'Unauthorized' ||
                msgs === 'Method Not Allowed') &&
                (setStatus(token, 'Disconnect'),
                clearConnection(token),
                connectToWhatsApp(token, ev))
              proto === 'Stream Errored (restart required)' &&
                connectToWhatsApp(token, ev)
              proto === 'Connection was lost' && delete sock[token]
            } else {
              setStatus(token, 'Disconnect')
              console.log('Connection closed. You are logged out.')
              ev?.emit('message', {
                token: token,
                message: 'Connection closed. You are logged out.',
              })
              clearConnection(token)
              connectToWhatsApp(token, ev)
            }
          }
          qr &&
            (console.log('new qr', token),
            QRCode.toDataURL(qr, function (resMsg, qrCode) {
              if (resMsg) {
                console.log(resMsg)
              }
              qrcode[token] = qrCode
              connectToWhatsApp(token, ev, auth)
            }))
          if (connection === 'open') {
            console.log('OPEN OPEN OPEN')
            setStatus(token, 'Connected')
            delete qrcode[token]
            delete pairingCode[token]
            let PhoneNums = sock[token].user.id.split(':')
            PhoneNums = PhoneNums[0] + '@s.whatsapp.net'
            const ppUrl = await getPpUrl(token, PhoneNums)
            ev?.emit('connection-open', {
              token: token,
              user: sock[token].user,
              ppUrl: ppUrl,
            })
            delete qrcode[token]
            delete pairingCode[token]
          }
        }
        if (events['creds.update']) {
          const updateCreds = events['creds.update']
          saveCreds(updateCreds)
        }
        if (events['messages.upsert']) {
          const msgUpsert = events['messages.upsert']
          IncomingMessage(msgUpsert, sock[token])
        }
      }),
      {
        sock: sock[token],
        qrcode: qrcode[token],
      }
    )
  }
async function connectWaBeforeSend(connTo) {
  let undConn = undefined,	
    connWa
  connWa = await connectToWhatsApp(connTo)
  await connWa.sock.ev.on('connection.update', (qrtoken) => {
    const { connection: connection, qr: qr } = qrtoken
    connection === 'open' && (undConn = true)
    qr && (undConn = false)
  })
  let i = 0
  while (typeof undConn === 'undefined') {
    i++
    if (i > 4) {
      break
    }
    await new Promise((resolve) => setTimeout(resolve, 1000))
  }
  return undConn
}
const sendText = async (token, format, tests) => {
    try {
      const conn = await sock[token].sendMessage(
        formatReceipt(format),
        { text: tests }
      )
      return conn
    } catch (error) {
      return false
    }
  },
  sendMessage = async (token, format, jsonString) => {
    try {
      const conn = await sock[token].sendMessage(
        formatReceipt(format),
        JSON.parse(jsonString)
      )
      return conn
    } catch (error) {
      return false
    }
  }
async function sendMedia(
  token,
  format,
  type,
  url,
  caption,
  options,
  fileName
) {
  const id = formatReceipt(format)
  let Jid = sock[token].user.id.replace(/:\d+/, '')
  if (type == 'audio') {
    return await sock[token].sendMessage(id, {
      audio: { url: url },
      ptt: true,
      mimetype: 'audio/mpeg',
    })
  }
  const resPrep = await prepareMediaMessage(sock[token], {
      caption: caption ? caption : '',
      fileName: fileName,
      media: url,
      mediatype:
        type !== 'video' && type !== 'image' ? 'document' : type,
    }),
    message = { ...resPrep.message }
  return await sock[token].sendMessage(id, {
    forward: {
      key: {
        remoteJid: Jid,
        fromMe: true,
      },
      message: message,
    },
  })
}
async function sendButtonMessage(
  token,
  format,
  list,
  caption,
  footer,
  url
) {
  let type = 'url'
  try {
    const buttons = list.map((string, buttonId) => {
      return {
        buttonId: buttonId,
        buttonText: { displayText: string.displayText },
        type: 1,
      }
    })
    if (url) {
      var isimg = {
        image:
          type == 'url'
            ? { url: url }
            : fs.readFileSync('src/public/temp/' + url),
        caption: caption,
        footer: footer,
        buttons: buttons,
        headerType: 4,
        viewOnce: true,
      }
    } else {
      var isimg = {
        text: caption,
        footer: footer,
        buttons: buttons,
        headerType: 1,
        viewOnce: true,
      }
    }
    const sendMs = await sock[token].sendMessage(
      formatReceipt(format),
      isimg
    )
    return sendMs
  } catch (error) {
    return console.log(error), false
  }
}
async function sendTemplateMessage(
  token,
  format,
  templateButtons,
  caption,
  footer,
  url
) {
  try {
    if (url) {
      var types = {
        caption: caption,
        footer: footer,
        viewOnce: true,
        templateButtons: templateButtons,
        image: { url: url },
        viewOnce: true,
      }
    } else {
      var types = {
        text: caption,
        footer: footer,
        viewOnce: true,
        templateButtons: templateButtons,
      }
    }
    const resSendMsg = await sock[token].sendMessage(
      formatReceipt(format),
      types
    )
    return resSendMsg
  } catch (error) {
    return console.log(error), false
  }
}
async function sendListMessage(
  token,
  format,
  sections,
  texts,
  footer,
  title,
  buttonText
) {
  try {
    const Lists = {
        text: texts,
        footer: footer,
        title: title,
        buttonText: buttonText,
        sections: [sections],
      },
      resSendMsg = await sock[token].sendMessage(
        formatReceipt(format),
        Lists,
        { ephemeralExpiration: 604800 }
      )
    return resSendMsg
  } catch (error) {
    return console.log(error), false
  }
}
async function sendPollMessage(
  token,
  format,
  name,
  values,
  selectableCount
) {
  try {
    const ResSendMsg = await sock[token].sendMessage(
      formatReceipt(format),
      {
        poll: {
          name: name,
          values: values,
          selectableCount: selectableCount,
        },
      }
    )
    return ResSendMsg
  } catch (error) {
    return console.log(error), false
  }
}
async function fetchGroups(token) {
  try {
    let GetAll = await sock[token].groupFetchAllParticipating(),
      ResGet = Object.entries(GetAll)
        .slice(0)
        .map((MapGroup) => MapGroup[1])
    return ResGet
  } catch (error) {
    return false
  }
}
async function isExist(token, PhoneNum) {
  try {
    if (typeof sock[token] === 'undefined') {
      const ConnBe = await connectWaBeforeSend(token)
      if (!ConnBe) {
        return false
      }
    }
    if (PhoneNum.includes('@g.us')) {
      return true
    } else {
      const [isNum] = await sock[token].onWhatsApp('+' + PhoneNum)
      return PhoneNum.length > 11 ? isNum : true
    }
  } catch (error) {
    return false
  }
}
async function getPpUrl(token, string, type) {
  let imgPp
  try {
    return (
      (imgPp = await sock[token].profilePictureUrl(string)),
      imgPp
    )
  } catch (error) {
    return 'https://upload.wikimedia.org/wikipedia/commons/thumb/6/6b/WhatsApp.svg/1200px-WhatsApp.svg.png'
  }
}
async function deleteCredentials(token, evs = null) {
  evs !== null &&
    evs.emit('message', {
      token: token,
      message: 'Logout Progres..',
    })
  try {
    if (typeof sock[token] === 'undefined') {
      const ConnWaBe = await connectWaBeforeSend(token)
      ConnWaBe && (sock[token].logout(), delete sock[token])
    } else {
      sock[token].logout()
      delete sock[token]
    }
    return (
      delete qrcode[token],
      clearInterval(intervalStore[token]),
      setStatus(token, 'Disconnect'),
      evs != null &&
        (evs.emit('Unauthorized', token),
        evs.emit('message', {
          token: token,
          message: 'Connection closed. You are logged out.',
        })),
      fs.existsSync('./credentials/' + token) &&
        fs.rmSync(
          './credentials/' + token,
          {
            recursive: true,
            force: true,
          },
          (debug) => {
            if (debug) {
              console.log(debug)
            }
          }
        ),
      {
        status: true,
        message: 'Deleting session and credential',
      }
    )
  } catch (error) {
    return (
      console.log(error),
      {
        status: true,
        message: 'Nothing deleted',
      }
    )
  }
}
function clearConnection(token) {
  clearInterval(intervalStore[token])
  delete sock[token]
  delete qrcode[token]
  setStatus(token, 'Disconnect')
  fs.existsSync('./credentials/' + token) &&
    (fs.rmSync(
      './credentials/' + token,
      {
        recursive: true,
        force: true,
      },
      (debug) => {
        if (debug) {
          console.log(debug)
        }
      }
    ),
    console.log('credentials/' + token + ' is deleted'))
}
async function initialize(filetoken, result) {
  const { token: token } = filetoken.body
  if (token) {
    const readFileSync = require('fs'),
      path = './credentials/' + token
    if (readFileSync.existsSync(path)) {
      sock[token] = undefined
      const resultBefore = await connectWaBeforeSend(token)
      return resultBefore
        ? result.status(200).json({
            status: true,
            message: token + ' connection restored',
          })
        : result.status(200).json({
            status: false,
            message: token + ' connection failed',
          })
    }
    return result.send({
      status: false,
      message: token + ' Connection failed,please scan first',
    })
  }
  return result.send({
    status: false,
    message: 'Wrong Parameterss',
  })
}
module.exports = {
  connectToWhatsApp: connectToWhatsApp,
  sendText: sendText,
  sendMedia: sendMedia,
  sendButtonMessage: sendButtonMessage,
  sendTemplateMessage: sendTemplateMessage,
  sendListMessage: sendListMessage,
  sendPollMessage: sendPollMessage,
  isExist: isExist,
  getPpUrl: getPpUrl,
  fetchGroups: fetchGroups,
  deleteCredentials: deleteCredentials,
  sendMessage: sendMessage,
  initialize: initialize,
  connectWaBeforeSend: connectWaBeforeSend,
  sock: sock,
}

whatsapp.js

Edited Monday at 09:38 AM by Magd Almuntaser

pak kacung · Monday at 04:26 AM

6 hours ago, Magd Almuntaser said:

you can but not 3k numbers .. only 255 every broadcast .. you need to change some files to able to send to brodcast ..
whatsapp gateway script use lib (WhiskeySockets/Baileys) that can login, send msg .. etc
so you can go to here:

github_com/WhiskeySockets/Baileys/pull/249

i've decoded (server/whatsapp.js) file for you so you can change anything you want:

/**************************/
/*    Nulled & Decoded    */
/*   By Magd Almuntaser   */
/*         TTMTT          */
/**************************/

const { Boom } = require('@hapi/boom')
const {
  default: makeWASocket,
  Browsers,
  fetchLatestBaileysVersion,
  useMultiFileAuthState,
  makeCacheableSignalKeyStore,
  DisconnectReason,
} = require('@whiskeysockets/baileys')
const QRCode = require('qrcode'),
  fs = require('fs')
let sock = [],
  qrcode = [],
  pairingCode = [],
  intervalStore = []
const { setStatus } = require('./database/index'),
  { IncomingMessage } = require('./controllers/incomingMessage'),
  {
    formatReceipt,
    getSavedPhoneNumber,
    prepareMediaMessage,
  } = require('./lib/helper'),
  MAIN_LOGGER = require('./lib/pino'),
  NodeCache = require('node-cache'),
  logger = MAIN_LOGGER.child({}),
  msgRetryCounterCache = new NodeCache(),
  connectToWhatsApp = async (
    token,
    ev = null,
    auth = false
  ) => {
    if (typeof qrcode[token] !== 'undefined' && !auth) {
      return (
        ev?.emit('qrcode', {
          token: token,
          data: qrcode[token],
          message: 'please scan with your Whatsapp Accountt',
        }),
        {
          status: false,
          sock: sock[token],
          qrcode: qrcode[token],
          message: 'please scan',
        }
      )
    }
    if (typeof pairingCode[token] !== 'undefined' && auth) {
      return (
        ev?.emit('code', {
          token: token,
          data: pairingCode[token],
          message:
            'Go to whatsapp -> link device -> link with phone number, and pairing with this code.',
        }),
        {
          status: false,
          code: pairingCode[token],
          message: 'pairing with that code',
        }
      )
    }
    try {
      let phoneNum = sock[token].user.id.split(':')
      phoneNum = phoneNum[0] + '@s.whatsapp.net'
      const ppUrl = await getPpUrl(token, phoneNum)
      return (
        ev?.emit('connection-open', {
          token: token,
          user: sock[token].user,
          ppUrl: ppUrl,
        }),
        delete qrcode[token],
        delete pairingCode[token],
        {
          status: true,
          message: 'Already connected',
        }
      )
    } catch (error) {
      ev?.emit('message', {
        token: token,
        message: 'Connecting.. (1)..',
      })
    }
    const { version: version, isLatest: isLatest } =
      await fetchLatestBaileysVersion()
    console.log(
      'You re using whatsapp gateway M Pedia v6.1.0 - Contact admin if any trouble : 6292298859671'
    )
    console.log('using WA v' + version.join('.') + ', isLatest: ' + isLatest)
    const { state: state, saveCreds: saveCreds } =
      await useMultiFileAuthState('./credentials/' + token)
    sock[token] = makeWASocket({
      version: version,
      browser: Browsers.macOS('Chrome', 'Mpedia'),
      logger: logger,
      printQRInTerminal: false,
      auth: {
        creds: state.creds,
        keys: makeCacheableSignalKeyStore(state.keys, logger),
      },
      msgRetryCounterCache: msgRetryCounterCache,
      generateHighQualityLinkPreview: true,
    })
    if (auth && 'me' in state.creds === false) {
      const phoneNumber = await getSavedPhoneNumber(token)
      try {
        const code = await sock[token].requestPairingCode(phoneNumber)
        pairingCode[token] = code
      } catch (error) {
        ev?.emit('message', {
          token: token,
          message: 'Time out, please refresh page',
        })
      }
      ev?.emit('code', {
        token: token,
        data: pairingCode[token],
        message:
          'Go to whatsapp -> link device -> link with phone number, and pairing with this code.',
      })
    }
    return (
      sock[token].ev.process(async (events) => {
        if (events['connection.update']) {
          const update = events['connection.update'],
            {
              connection: connection,
              lastDisconnect: lastDisconnect,
              qr: qr,
            } = update
          if (connection === 'close') {
            const proto = lastDisconnect.error?.output?.payload?.message,
              msgs = lastDisconnect.error?.output?.payload?.error
            if (
              (lastDisconnect?.error instanceof Boom)?.output?.statusCode !==
              DisconnectReason.loggedOut
            ) {
              delete qrcode[token]
              ev?.emit('message', {
                token: token,
                message: 'Connecting..',
              })
              if (proto == 'QR refs attempts ended') {
                sock[token].ws.close()
                delete qrcode[token]
                delete pairingCode[token]
                delete sock[token]
                ev?.emit('message', {
                  token: token,
                  message: 'Request QR ended. reload web to scan again',
                })
                return
              }
              ;(msgs === 'Unauthorized' ||
                msgs === 'Method Not Allowed') &&
                (setStatus(token, 'Disconnect'),
                clearConnection(token),
                connectToWhatsApp(token, ev))
              proto === 'Stream Errored (restart required)' &&
                connectToWhatsApp(token, ev)
              proto === 'Connection was lost' && delete sock[token]
            } else {
              setStatus(token, 'Disconnect')
              console.log('Connection closed. You are logged out.')
              ev?.emit('message', {
                token: token,
                message: 'Connection closed. You are logged out.',
              })
              clearConnection(token)
              connectToWhatsApp(token, ev)
            }
          }
          qr &&
            (console.log('new qr', token),
            QRCode.toDataURL(qr, function (resMsg, qrCode) {
              if (resMsg) {
                console.log(resMsg)
              }
              qrcode[token] = qrCode
              connectToWhatsApp(token, ev, auth)
            }))
          if (connection === 'open') {
            console.log('OPEN OPEN OPEN')
            setStatus(token, 'Connected')
            delete qrcode[token]
            delete pairingCode[token]
            let PhoneNums = sock[token].user.id.split(':')
            PhoneNums = PhoneNums[0] + '@s.whatsapp.net'
            const ppUrl = await getPpUrl(token, PhoneNums)
            ev?.emit('connection-open', {
              token: token,
              user: sock[token].user,
              ppUrl: ppUrl,
            })
            delete qrcode[token]
            delete pairingCode[token]
          }
        }
        if (events['creds.update']) {
          const updateCreds = events['creds.update']
          saveCreds(updateCreds)
        }
        if (events['messages.upsert']) {
          const msgUpsert = events['messages.upsert']
          IncomingMessage(msgUpsert, sock[token])
        }
      }),
      {
        sock: sock[token],
        qrcode: qrcode[token],
      }
    )
  }
async function connectWaBeforeSend(connTo) {
  let undConn = undefined,	
    connWa
  connWa = await connectToWhatsApp(connTo)
  await connWa.sock.ev.on('connection.update', (qrtoken) => {
    const { connection: connection, qr: qr } = qrtoken
    connection === 'open' && (undConn = true)
    qr && (undConn = false)
  })
  let i = 0
  while (typeof undConn === 'undefined') {
    i++
    if (i > 4) {
      break
    }
    await new Promise((resolve) => setTimeout(resolve, 1000))
  }
  return undConn
}
const sendText = async (token, format, tests) => {
    try {
      const conn = await sock[token].sendMessage(
        formatReceipt(format),
        { text: tests }
      )
      return conn
    } catch (error) {
      return false
    }
  },
  sendMessage = async (token, format, jsonString) => {
    try {
      const conn = await sock[token].sendMessage(
        formatReceipt(format),
        JSON.parse(jsonString)
      )
      return conn
    } catch (error) {
      return false
    }
  }
async function sendMedia(
  token,
  format,
  type,
  url,
  caption,
  options,
  fileName
) {
  const id = formatReceipt(format)
  let Jid = sock[token].user.id.replace(/:\d+/, '')
  if (type == 'audio') {
    return await sock[token].sendMessage(id, {
      audio: { url: url },
      ptt: true,
      mimetype: 'audio/mpeg',
    })
  }
  const resPrep = await prepareMediaMessage(sock[token], {
      caption: caption ? caption : '',
      fileName: fileName,
      media: url,
      mediatype:
        type !== 'video' && type !== 'image' ? 'document' : type,
    }),
    message = { ...resPrep.message }
  return await sock[token].sendMessage(id, {
    forward: {
      key: {
        remoteJid: Jid,
        fromMe: true,
      },
      message: message,
    },
  })
}
async function sendButtonMessage(
  token,
  format,
  list,
  caption,
  footer,
  url
) {
  let type = 'url'
  try {
    const buttons = list.map((string, buttonId) => {
      return {
        buttonId: buttonId,
        buttonText: { displayText: string.displayText },
        type: 1,
      }
    })
    if (url) {
      var isimg = {
        image:
          type == 'url'
            ? { url: url }
            : fs.readFileSync('src/public/temp/' + url),
        caption: caption,
        footer: footer,
        buttons: buttons,
        headerType: 4,
        viewOnce: true,
      }
    } else {
      var isimg = {
        text: caption,
        footer: footer,
        buttons: buttons,
        headerType: 1,
        viewOnce: true,
      }
    }
    const sendMs = await sock[token].sendMessage(
      formatReceipt(format),
      isimg
    )
    return sendMs
  } catch (error) {
    return console.log(error), false
  }
}
async function sendTemplateMessage(
  token,
  format,
  templateButtons,
  caption,
  footer,
  url
) {
  try {
    if (url) {
      var types = {
        caption: caption,
        footer: footer,
        viewOnce: true,
        templateButtons: templateButtons,
        image: { url: url },
        viewOnce: true,
      }
    } else {
      var types = {
        text: caption,
        footer: footer,
        viewOnce: true,
        templateButtons: templateButtons,
      }
    }
    const resSendMsg = await sock[token].sendMessage(
      formatReceipt(format),
      types
    )
    return resSendMsg
  } catch (error) {
    return console.log(error), false
  }
}
async function sendListMessage(
  token,
  format,
  sections,
  texts,
  footer,
  title,
  buttonText
) {
  try {
    const Lists = {
        text: texts,
        footer: footer,
        title: title,
        buttonText: buttonText,
        sections: [sections],
      },
      resSendMsg = await sock[token].sendMessage(
        formatReceipt(format),
        Lists,
        { ephemeralExpiration: 604800 }
      )
    return resSendMsg
  } catch (error) {
    return console.log(error), false
  }
}
async function sendPollMessage(
  token,
  format,
  name,
  values,
  selectableCount
) {
  try {
    const ResSendMsg = await sock[token].sendMessage(
      formatReceipt(format),
      {
        poll: {
          name: name,
          values: values,
          selectableCount: selectableCount,
        },
      }
    )
    return ResSendMsg
  } catch (error) {
    return console.log(error), false
  }
}
async function fetchGroups(token) {
  try {
    let GetAll = await sock[token].groupFetchAllParticipating(),
      ResGet = Object.entries(GetAll)
        .slice(0)
        .map((MapGroup) => MapGroup[1])
    return ResGet
  } catch (error) {
    return false
  }
}
async function isExist(token, PhoneNum) {
  try {
    if (typeof sock[token] === 'undefined') {
      const ConnBe = await connectWaBeforeSend(token)
      if (!ConnBe) {
        return false
      }
    }
    if (PhoneNum.includes('@g.us')) {
      return true
    } else {
      const [isNum] = await sock[token].onWhatsApp('+' + PhoneNum)
      return PhoneNum.length > 11 ? isNum : true
    }
  } catch (error) {
    return false
  }
}
async function getPpUrl(token, string, type) {
  let imgPp
  try {
    return (
      (imgPp = await sock[token].profilePictureUrl(string)),
      imgPp
    )
  } catch (error) {
    return 'https://upload.wikimedia.org/wikipedia/commons/thumb/6/6b/WhatsApp.svg/1200px-WhatsApp.svg.png'
  }
}
async function deleteCredentials(token, evs = null) {
  evs !== null &&
    evs.emit('message', {
      token: token,
      message: 'Logout Progres..',
    })
  try {
    if (typeof sock[token] === 'undefined') {
      const ConnWaBe = await connectWaBeforeSend(token)
      ConnWaBe && (sock[token].logout(), delete sock[token])
    } else {
      sock[token].logout()
      delete sock[token]
    }
    return (
      delete qrcode[token],
      clearInterval(intervalStore[token]),
      setStatus(token, 'Disconnect'),
      evs != null &&
        (evs.emit('Unauthorized', token),
        evs.emit('message', {
          token: token,
          message: 'Connection closed. You are logged out.',
        })),
      fs.existsSync('./credentials/' + token) &&
        fs.rmSync(
          './credentials/' + token,
          {
            recursive: true,
            force: true,
          },
          (debug) => {
            if (debug) {
              console.log(debug)
            }
          }
        ),
      {
        status: true,
        message: 'Deleting session and credential',
      }
    )
  } catch (error) {
    return (
      console.log(error),
      {
        status: true,
        message: 'Nothing deleted',
      }
    )
  }
}
function clearConnection(token) {
  clearInterval(intervalStore[token])
  delete sock[token]
  delete qrcode[token]
  setStatus(token, 'Disconnect')
  fs.existsSync('./credentials/' + token) &&
    (fs.rmSync(
      './credentials/' + token,
      {
        recursive: true,
        force: true,
      },
      (debug) => {
        if (debug) {
          console.log(debug)
        }
      }
    ),
    console.log('credentials/' + token + ' is deleted'))
}
async function initialize(filetoken, result) {
  const { token: token } = filetoken.body
  if (token) {
    const readFileSync = require('fs'),
      path = './credentials/' + token
    if (readFileSync.existsSync(path)) {
      sock[token] = undefined
      const resultBefore = await connectWaBeforeSend(token)
      return resultBefore
        ? result.status(200).json({
            status: true,
            message: token + ' connection restored',
          })
        : result.status(200).json({
            status: false,
            message: token + ' connection failed',
          })
    }
    return result.send({
      status: false,
      message: token + ' Connection failed,please scan first',
    })
  }
  return result.send({
    status: false,
    message: 'Wrong Parameterss',
  })
}
module.exports = {
  connectToWhatsApp: connectToWhatsApp,
  sendText: sendText,
  sendMedia: sendMedia,
  sendButtonMessage: sendButtonMessage,
  sendTemplateMessage: sendTemplateMessage,
  sendListMessage: sendListMessage,
  sendPollMessage: sendPollMessage,
  isExist: isExist,
  getPpUrl: getPpUrl,
  fetchGroups: fetchGroups,
  deleteCredentials: deleteCredentials,
  sendMessage: sendMessage,
  initialize: initialize,
  connectWaBeforeSend: connectWaBeforeSend,
  sock: sock,
}

whatsapp.js 15.54 kB · 3 downloads

ini di replace di whatsapp.js yang ada di folder server ya?

The Billionaire · Monday at 08:51 AM

11 hours ago, Magd Almuntaser said:

you can but not 3k numbers .. only 255 every broadcast .. you need to change some files to able to send to brodcast ..
whatsapp gateway script use lib (WhiskeySockets/Baileys) that can login, send msg .. etc
so you can go to here:

github_com/WhiskeySockets/Baileys/pull/249

i've decoded (server/whatsapp.js) file for you so you can change anything you want:

/**************************/
/*    Nulled & Decoded    */
/*   By Magd Almuntaser   */
/*         TTMTT          */
/**************************/

const { Boom } = require('@hapi/boom')
const {
  default: makeWASocket,
  Browsers,
  fetchLatestBaileysVersion,
  useMultiFileAuthState,
  makeCacheableSignalKeyStore,
  DisconnectReason,
} = require('@whiskeysockets/baileys')
const QRCode = require('qrcode'),
  fs = require('fs')
let sock = [],
  qrcode = [],
  pairingCode = [],
  intervalStore = []
const { setStatus } = require('./database/index'),
  { IncomingMessage } = require('./controllers/incomingMessage'),
  {
    formatReceipt,
    getSavedPhoneNumber,
    prepareMediaMessage,
  } = require('./lib/helper'),
  MAIN_LOGGER = require('./lib/pino'),
  NodeCache = require('node-cache'),
  logger = MAIN_LOGGER.child({}),
  msgRetryCounterCache = new NodeCache(),
  connectToWhatsApp = async (
    token,
    ev = null,
    auth = false
  ) => {
    if (typeof qrcode[token] !== 'undefined' && !auth) {
      return (
        ev?.emit('qrcode', {
          token: token,
          data: qrcode[token],
          message: 'please scan with your Whatsapp Accountt',
        }),
        {
          status: false,
          sock: sock[token],
          qrcode: qrcode[token],
          message: 'please scan',
        }
      )
    }
    if (typeof pairingCode[token] !== 'undefined' && auth) {
      return (
        ev?.emit('code', {
          token: token,
          data: pairingCode[token],
          message:
            'Go to whatsapp -> link device -> link with phone number, and pairing with this code.',
        }),
        {
          status: false,
          code: pairingCode[token],
          message: 'pairing with that code',
        }
      )
    }
    try {
      let phoneNum = sock[token].user.id.split(':')
      phoneNum = phoneNum[0] + '@s.whatsapp.net'
      const ppUrl = await getPpUrl(token, phoneNum)
      return (
        ev?.emit('connection-open', {
          token: token,
          user: sock[token].user,
          ppUrl: ppUrl,
        }),
        delete qrcode[token],
        delete pairingCode[token],
        {
          status: true,
          message: 'Already connected',
        }
      )
    } catch (error) {
      ev?.emit('message', {
        token: token,
        message: 'Connecting.. (1)..',
      })
    }
    const { version: version, isLatest: isLatest } =
      await fetchLatestBaileysVersion()
    console.log(
      'You re using whatsapp gateway M Pedia v6.1.0 - Contact admin if any trouble : 6292298859671'
    )
    console.log('using WA v' + version.join('.') + ', isLatest: ' + isLatest)
    const { state: state, saveCreds: saveCreds } =
      await useMultiFileAuthState('./credentials/' + token)
    sock[token] = makeWASocket({
      version: version,
      browser: Browsers.macOS('Chrome', 'Mpedia'),
      logger: logger,
      printQRInTerminal: false,
      auth: {
        creds: state.creds,
        keys: makeCacheableSignalKeyStore(state.keys, logger),
      },
      msgRetryCounterCache: msgRetryCounterCache,
      generateHighQualityLinkPreview: true,
    })
    if (auth && 'me' in state.creds === false) {
      const phoneNumber = await getSavedPhoneNumber(token)
      try {
        const code = await sock[token].requestPairingCode(phoneNumber)
        pairingCode[token] = code
      } catch (error) {
        ev?.emit('message', {
          token: token,
          message: 'Time out, please refresh page',
        })
      }
      ev?.emit('code', {
        token: token,
        data: pairingCode[token],
        message:
          'Go to whatsapp -> link device -> link with phone number, and pairing with this code.',
      })
    }
    return (
      sock[token].ev.process(async (events) => {
        if (events['connection.update']) {
          const update = events['connection.update'],
            {
              connection: connection,
              lastDisconnect: lastDisconnect,
              qr: qr,
            } = update
          if (connection === 'close') {
            const proto = lastDisconnect.error?.output?.payload?.message,
              msgs = lastDisconnect.error?.output?.payload?.error
            if (
              (lastDisconnect?.error instanceof Boom)?.output?.statusCode !==
              DisconnectReason.loggedOut
            ) {
              delete qrcode[token]
              ev?.emit('message', {
                token: token,
                message: 'Connecting..',
              })
              if (proto == 'QR refs attempts ended') {
                sock[token].ws.close()
                delete qrcode[token]
                delete pairingCode[token]
                delete sock[token]
                ev?.emit('message', {
                  token: token,
                  message: 'Request QR ended. reload web to scan again',
                })
                return
              }
              ;(msgs === 'Unauthorized' ||
                msgs === 'Method Not Allowed') &&
                (setStatus(token, 'Disconnect'),
                clearConnection(token),
                connectToWhatsApp(token, ev))
              proto === 'Stream Errored (restart required)' &&
                connectToWhatsApp(token, ev)
              proto === 'Connection was lost' && delete sock[token]
            } else {
              setStatus(token, 'Disconnect')
              console.log('Connection closed. You are logged out.')
              ev?.emit('message', {
                token: token,
                message: 'Connection closed. You are logged out.',
              })
              clearConnection(token)
              connectToWhatsApp(token, ev)
            }
          }
          qr &&
            (console.log('new qr', token),
            QRCode.toDataURL(qr, function (resMsg, qrCode) {
              if (resMsg) {
                console.log(resMsg)
              }
              qrcode[token] = qrCode
              connectToWhatsApp(token, ev, auth)
            }))
          if (connection === 'open') {
            console.log('OPEN OPEN OPEN')
            setStatus(token, 'Connected')
            delete qrcode[token]
            delete pairingCode[token]
            let PhoneNums = sock[token].user.id.split(':')
            PhoneNums = PhoneNums[0] + '@s.whatsapp.net'
            const ppUrl = await getPpUrl(token, PhoneNums)
            ev?.emit('connection-open', {
              token: token,
              user: sock[token].user,
              ppUrl: ppUrl,
            })
            delete qrcode[token]
            delete pairingCode[token]
          }
        }
        if (events['creds.update']) {
          const updateCreds = events['creds.update']
          saveCreds(updateCreds)
        }
        if (events['messages.upsert']) {
          const msgUpsert = events['messages.upsert']
          IncomingMessage(msgUpsert, sock[token])
        }
      }),
      {
        sock: sock[token],
        qrcode: qrcode[token],
      }
    )
  }
async function connectWaBeforeSend(connTo) {
  let undConn = undefined,	
    connWa
  connWa = await connectToWhatsApp(connTo)
  await connWa.sock.ev.on('connection.update', (qrtoken) => {
    const { connection: connection, qr: qr } = qrtoken
    connection === 'open' && (undConn = true)
    qr && (undConn = false)
  })
  let i = 0
  while (typeof undConn === 'undefined') {
    i++
    if (i > 4) {
      break
    }
    await new Promise((resolve) => setTimeout(resolve, 1000))
  }
  return undConn
}
const sendText = async (token, format, tests) => {
    try {
      const conn = await sock[token].sendMessage(
        formatReceipt(format),
        { text: tests }
      )
      return conn
    } catch (error) {
      return false
    }
  },
  sendMessage = async (token, format, jsonString) => {
    try {
      const conn = await sock[token].sendMessage(
        formatReceipt(format),
        JSON.parse(jsonString)
      )
      return conn
    } catch (error) {
      return false
    }
  }
async function sendMedia(
  token,
  format,
  type,
  url,
  caption,
  options,
  fileName
) {
  const id = formatReceipt(format)
  let Jid = sock[token].user.id.replace(/:\d+/, '')
  if (type == 'audio') {
    return await sock[token].sendMessage(id, {
      audio: { url: url },
      ptt: true,
      mimetype: 'audio/mpeg',
    })
  }
  const resPrep = await prepareMediaMessage(sock[token], {
      caption: caption ? caption : '',
      fileName: fileName,
      media: url,
      mediatype:
        type !== 'video' && type !== 'image' ? 'document' : type,
    }),
    message = { ...resPrep.message }
  return await sock[token].sendMessage(id, {
    forward: {
      key: {
        remoteJid: Jid,
        fromMe: true,
      },
      message: message,
    },
  })
}
async function sendButtonMessage(
  token,
  format,
  list,
  caption,
  footer,
  url
) {
  let type = 'url'
  try {
    const buttons = list.map((string, buttonId) => {
      return {
        buttonId: buttonId,
        buttonText: { displayText: string.displayText },
        type: 1,
      }
    })
    if (url) {
      var isimg = {
        image:
          type == 'url'
            ? { url: url }
            : fs.readFileSync('src/public/temp/' + url),
        caption: caption,
        footer: footer,
        buttons: buttons,
        headerType: 4,
        viewOnce: true,
      }
    } else {
      var isimg = {
        text: caption,
        footer: footer,
        buttons: buttons,
        headerType: 1,
        viewOnce: true,
      }
    }
    const sendMs = await sock[token].sendMessage(
      formatReceipt(format),
      isimg
    )
    return sendMs
  } catch (error) {
    return console.log(error), false
  }
}
async function sendTemplateMessage(
  token,
  format,
  templateButtons,
  caption,
  footer,
  url
) {
  try {
    if (url) {
      var types = {
        caption: caption,
        footer: footer,
        viewOnce: true,
        templateButtons: templateButtons,
        image: { url: url },
        viewOnce: true,
      }
    } else {
      var types = {
        text: caption,
        footer: footer,
        viewOnce: true,
        templateButtons: templateButtons,
      }
    }
    const resSendMsg = await sock[token].sendMessage(
      formatReceipt(format),
      types
    )
    return resSendMsg
  } catch (error) {
    return console.log(error), false
  }
}
async function sendListMessage(
  token,
  format,
  sections,
  texts,
  footer,
  title,
  buttonText
) {
  try {
    const Lists = {
        text: texts,
        footer: footer,
        title: title,
        buttonText: buttonText,
        sections: [sections],
      },
      resSendMsg = await sock[token].sendMessage(
        formatReceipt(format),
        Lists,
        { ephemeralExpiration: 604800 }
      )
    return resSendMsg
  } catch (error) {
    return console.log(error), false
  }
}
async function sendPollMessage(
  token,
  format,
  name,
  values,
  selectableCount
) {
  try {
    const ResSendMsg = await sock[token].sendMessage(
      formatReceipt(format),
      {
        poll: {
          name: name,
          values: values,
          selectableCount: selectableCount,
        },
      }
    )
    return ResSendMsg
  } catch (error) {
    return console.log(error), false
  }
}
async function fetchGroups(token) {
  try {
    let GetAll = await sock[token].groupFetchAllParticipating(),
      ResGet = Object.entries(GetAll)
        .slice(0)
        .map((MapGroup) => MapGroup[1])
    return ResGet
  } catch (error) {
    return false
  }
}
async function isExist(token, PhoneNum) {
  try {
    if (typeof sock[token] === 'undefined') {
      const ConnBe = await connectWaBeforeSend(token)
      if (!ConnBe) {
        return false
      }
    }
    if (PhoneNum.includes('@g.us')) {
      return true
    } else {
      const [isNum] = await sock[token].onWhatsApp('+' + PhoneNum)
      return PhoneNum.length > 11 ? isNum : true
    }
  } catch (error) {
    return false
  }
}
async function getPpUrl(token, string, type) {
  let imgPp
  try {
    return (
      (imgPp = await sock[token].profilePictureUrl(string)),
      imgPp
    )
  } catch (error) {
    return 'https://upload.wikimedia.org/wikipedia/commons/thumb/6/6b/WhatsApp.svg/1200px-WhatsApp.svg.png'
  }
}
async function deleteCredentials(token, evs = null) {
  evs !== null &&
    evs.emit('message', {
      token: token,
      message: 'Logout Progres..',
    })
  try {
    if (typeof sock[token] === 'undefined') {
      const ConnWaBe = await connectWaBeforeSend(token)
      ConnWaBe && (sock[token].logout(), delete sock[token])
    } else {
      sock[token].logout()
      delete sock[token]
    }
    return (
      delete qrcode[token],
      clearInterval(intervalStore[token]),
      setStatus(token, 'Disconnect'),
      evs != null &&
        (evs.emit('Unauthorized', token),
        evs.emit('message', {
          token: token,
          message: 'Connection closed. You are logged out.',
        })),
      fs.existsSync('./credentials/' + token) &&
        fs.rmSync(
          './credentials/' + token,
          {
            recursive: true,
            force: true,
          },
          (debug) => {
            if (debug) {
              console.log(debug)
            }
          }
        ),
      {
        status: true,
        message: 'Deleting session and credential',
      }
    )
  } catch (error) {
    return (
      console.log(error),
      {
        status: true,
        message: 'Nothing deleted',
      }
    )
  }
}
function clearConnection(token) {
  clearInterval(intervalStore[token])
  delete sock[token]
  delete qrcode[token]
  setStatus(token, 'Disconnect')
  fs.existsSync('./credentials/' + token) &&
    (fs.rmSync(
      './credentials/' + token,
      {
        recursive: true,
        force: true,
      },
      (debug) => {
        if (debug) {
          console.log(debug)
        }
      }
    ),
    console.log('credentials/' + token + ' is deleted'))
}
async function initialize(filetoken, result) {
  const { token: token } = filetoken.body
  if (token) {
    const readFileSync = require('fs'),
      path = './credentials/' + token
    if (readFileSync.existsSync(path)) {
      sock[token] = undefined
      const resultBefore = await connectWaBeforeSend(token)
      return resultBefore
        ? result.status(200).json({
            status: true,
            message: token + ' connection restored',
          })
        : result.status(200).json({
            status: false,
            message: token + ' connection failed',
          })
    }
    return result.send({
      status: false,
      message: token + ' Connection failed,please scan first',
    })
  }
  return result.send({
    status: false,
    message: 'Wrong Parameterss',
  })
}
module.exports = {
  connectToWhatsApp: connectToWhatsApp,
  sendText: sendText,
  sendMedia: sendMedia,
  sendButtonMessage: sendButtonMessage,
  sendTemplateMessage: sendTemplateMessage,
  sendListMessage: sendListMessage,
  sendPollMessage: sendPollMessage,
  isExist: isExist,
  getPpUrl: getPpUrl,
  fetchGroups: fetchGroups,
  deleteCredentials: deleteCredentials,
  sendMessage: sendMessage,
  initialize: initialize,
  connectWaBeforeSend: connectWaBeforeSend,
  sock: sock,
}

whatsapp.js 15.54 kB · 5 downloads

@Magd Almuntaser I have copied the code and replaced it inside the server/whatsapp.js so what else can I do now ???

Magd Almuntaser · Monday at 09:30 AM

5 hours ago, pak kacung said:

ini di replace di whatsapp.js yang ada di folder server ya?

Ya ..

39 minutes ago, The Billionaire said:

@Magd Almuntaser I have copied the code and replaced it inside the server/whatsapp.js so what else can I do now ???

I just decode the file ..

But i mean try to get the ID for boradcast so you can send msg to (id@broadcast) becouse WA7 don't have fetch broadcast id so you can change some function to get the broadcast id

id=msg_timestamp ..

So you need first get the id after that you can send normaly

Edited Monday at 09:32 AM by Magd Almuntaser

agus amin · Monday at 09:36 AM

4 minutes ago, Magd Almuntaser said:

Ya ..

I just decode the file ..

But i mean try to get the ID for boradcast so you can send msg to (id@broadcast) becouse WA7 don't have fetch broadcast id so you can change some function to get the broadcast id

id=msg_timestamp ..

So you need first get the id after that you can send normaly

Bro decode file js nya, semua file js di encrypt

The Billionaire · Monday at 10:29 AM

54 minutes ago, Magd Almuntaser said:

Ya ..

I just decode the file ..

But i mean try to get the ID for boradcast so you can send msg to (id@broadcast) becouse WA7 don't have fetch broadcast id so you can change some function to get the broadcast id

id=msg_timestamp ..

So you need first get the id after that you can send normaly

@Magd Almuntaser let me explain my issues hope you will understand, the broadcast is working, just that after it has been sent to 20 numbers from the 3k numbers WhatsApp blocked my line for spamming, although they have released my account, I want a way to prevent it from happening again when I resume the broadcast

Magd Almuntaser · Monday at 10:37 AM

4 minutes ago, The Billionaire said:

@Magd Almuntaser let me explain my issues hope you will understand, the broadcast is working, just that after it has been sent to 20 numbers from the 3k numbers WhatsApp blocked my line for spamming, although they have released my account, I want a way to prevent it from happening again when I resume the broadcast

If you send a broadcast, you won't be blocked. That's what surprised me.
Are you sure you used (status@broadcast) when you sent it?
Or did you just loop the numbers and send?