Retting av 404 Bad Request-feilen i WhatsApp API når du sender en mal gjennom Postman

Feilsøking 404-feil for WhatsApp-malmeldinger

Å sende en WhatsApp-malmelding via API kan være et kraftig verktøy, spesielt for markedsføringskampanjer. Det kan imidlertid oppstå problemer under prosessen, spesielt når du bruker Postman til testing. Et slikt problem er 404 Feil forespørsel, som kan blokkere leveringen av malmeldingen din.

Denne feilen oppstår ofte når det er et misforhold mellom malen som er opprettet på Meta og API-kallet til WhatsApp. Hvis du møter dette, er du ikke alene. Mange utviklere møter dette problemet, spesielt med maler som inkluderer rike medier som bilder.

Selv om malen har blitt opprettet og godkjent i Metas virksomhetsleder, kan det å sende den via Postman noen ganger utløse en 404-feil. Å forstå årsakene og feilsøkingstrinnene er avgjørende for å sikre jevn levering av meldingene dine.

I denne artikkelen vil vi lede deg gjennom mulige årsaker til dette 404 Dårlig forespørsel og tilby løsninger for å løse dette problemet. Fra å verifisere malkonfigurasjoner til å sikre riktig oppsett av API-anrop, vi dekker alt.

Forstå meldingsskript for WhatsApp-maler

Skriptene ovenfor viser hvordan du sender en WhatsApp-malmelding ved å bruke to forskjellige back-end-språk: Node.js og Python. Nøkkelfunksjonaliteten i begge skriptene dreier seg om å sende en HTTP POST-forespørsel til WhatsApp Business API vert av Meta, ved å bruke en spesifikk malmelding som var forhåndskonfigurert på Metas plattform. Malene kan inneholde ulike komponenter som tekst, bilder og overskrifter, som sendes som en del av API-forespørselen. En av hovedutfordringene er å håndtere 404 Dårlig forespørsel feil, ofte forårsaket av feilkonfigurasjoner i malen eller feil API-endepunkter.

I Node.js-skriptet bruker vi den populære aksioer biblioteket for å utføre API-forespørselen. Miljøvariablene, inkludert WhatsApp API-tokenet, administreres sikkert gjennom dotenv pakke. Dette sikrer at sensitive data ikke er hardkodet inn i skriptet, men i stedet lastes fra eksterne konfigurasjonsfiler. POST-forespørselen sender viktige data som mottakerens telefonnummer, malnavnet og dens dynamiske komponenter (f.eks. bilder). Hvis API-en svarer med en feil, sørger en try-catch-blokkering for at feilen logges og håndteres elegant, og unngår programkrasj.

På samme måte bruker Python-skriptet forespørsler bibliotek for å håndtere API-interaksjonen. Den følger samme struktur for å lage en HTTP POST-forespørsel til WhatsApp API, med miljøvariablene som håndteres via os.getenv. Denne metoden for bruk av miljøvariabler sikrer at API-tokenet og annen sensitiv informasjon administreres sikkert. Feilhåndteringen er enkel: den sjekker om HTTP-svarkoden er 404, noe som indikerer at den forespurte ressursen (i dette tilfellet malen eller endepunktet) ikke kan bli funnet. Dette gir mulighet for målrettede feilmeldinger som hjelper utviklere med å feilsøke problemet.

Begge skriptene er designet for å være modulære og gjenbrukbare. De sendWhatsAppTemplate funksjon i Node.js og send_mal_melding funksjon i Python innkapsle hele prosessen med å lage API-kallet. Denne tilnærmingen gjør at disse funksjonene enkelt kan integreres i større applikasjoner. Ved å gi dynamiske parametere som mottakernummer og malkomponenter, kan disse skriptene håndtere en rekke malmeldinger med minimale endringer, noe som gjør dem til allsidige verktøy for markedsføringskampanjer og kundeinteraksjoner.

// Required libraries
const axios = require('axios');
const dotenv = require('dotenv');
dotenv.config();

// WhatsApp API endpoint and token
const apiUrl = 'https://graph.facebook.com/v17.0/YOUR_PHONE_NUMBER_ID/messages';
const accessToken = process.env.WHATSAPP_API_TOKEN;

// Function to send template message
async function sendWhatsAppTemplate(recipient, templateName, components) {
 try {
   const response = await axios.post(apiUrl, {
     messaging_product: 'whatsapp',
     to: recipient,
     type: 'template',
     template: {
       name: templateName,
       language: { code: 'en_US' },
       components: components,
     },
   }, {
     headers: { Authorization: `Bearer ${accessToken}` },
   });

   console.log('Message sent successfully:', response.data);
 } catch (error) {
   if (error.response) {
     console.error('Error response:', error.response.data);
     if (error.response.status === 404) {
       console.error('Template not found or invalid API call');
     }
   } else {
     console.error('Error:', error.message);
   }
 }
}

// Example usage
const recipient = '1234567890';
const templateName = 'your_template_name';
const components = [{ type: 'header', parameters: [{ type: 'image', image: { link: 'https://example.com/image.jpg' }}]}];
sendWhatsAppTemplate(recipient, templateName, components);

import requests
import os

# API details
api_url = 'https://graph.facebook.com/v17.0/YOUR_PHONE_NUMBER_ID/messages'
access_token = os.getenv('WHATSAPP_API_TOKEN')

# Function to send WhatsApp template message
def send_template_message(recipient, template_name, components):
   headers = {'Authorization': f'Bearer {access_token}'}
   data = {
       "messaging_product": "whatsapp",
       "to": recipient,
       "type": "template",
       "template": {
           "name": template_name,
           "language": {"code": "en_US"},
           "components": components,
       }
   }

   response = requests.post(api_url, headers=headers, json=data)

   if response.status_code == 404:
       print('Error: Template not found or bad API call')
   else:
       print('Message sent successfully:', response.json())

# Example usage
recipient = '1234567890'
template_name = 'your_template_name'
components = [{ 'type': 'header', 'parameters': [{ 'type': 'image', 'image': {'link': 'https://example.com/image.jpg'}}]}]
send_template_message(recipient, template_name, components)

Adressering av malfeil i WhatsApp API-integrasjon

Et viktig aspekt ved vellykket sending av en WhatsApp-malmelding via WhatsApp API sikrer at malkonfigurasjonen i Metas plattform samsvarer med API-forespørselsparametrene. Ofte overser utviklere subtile krav som korrekte språkkoder, malnavn eller parameterstrukturer, noe som kan føre til 404 Dårlig forespørsel feil. Disse feilene oppstår når API-en ikke finner malen du prøver å sende, vanligvis på grunn av et misforhold mellom det som ble opprettet på Meta og det som kalles via API-en.

Et annet viktig punkt å vurdere er forskjellen mellom å sende en ren tekstmelding og å sende en melding som inneholder medier, for eksempel et bilde. For mediamaler kreves det tilleggskomponenter som overskrifter, og strukturen til disse komponentene må følge spesifikke retningslinjer. For eksempel bør bilder ha en gyldig URL eller lastes opp på en måte som API gjenkjenner dem. Å ignorere disse detaljene vil sannsynligvis føre til at meldingen mislykkes.

Testing av API-kall ved hjelp av verktøy som Postman er også en viktig del av utviklingsprosessen. Postman lar deg simulere ekte API-forespørsler og se svar direkte. En vanlig feil er imidlertid feilkonfigurering av forespørselens overskrifter eller brødtekst under testing. Sikre at de riktige overskriftene liker Autorisasjon med bærertoken og innholdstype er riktig angitt, er det avgjørende for API-et for å autentisere og behandle meldingen. Å følge disse fremgangsmåtene kan hjelpe deg med å unngå vanlige problemer og sikre vellykket levering av WhatsApp-malmeldingene dine.