Build a Discord Goal-Alert Bot: Live Football Scores in Your Server

npm init -y
npm pkg set type=module   # the examples use import syntax
npm install discord.js dotenv

## .env
DISCORD_TOKEN=your_bot_token
GOAL_API_KEY=your_goal_api_key
CLIENT_ID=your_application_id

// index.js — the client and a tiny GOAL API helper
import 'dotenv/config';
import { Client, GatewayIntentBits } from 'discord.js';

const client = new Client({ intents: [GatewayIntentBits.Guilds] });
const BASE = 'https://api.goal-api.com/v1';

async function goal(path) {
  const res = await fetch(`${BASE}${path}`, {
    headers: { Authorization: `Bearer ${process.env.GOAL_API_KEY}` },
  });
  if (!res.ok) throw new Error(`GOAL API ${res.status}`);
  return (await res.json()).data;
}

client.once('ready', () => console.log(`Logged in as ${client.user.tag}`));
client.login(process.env.DISCORD_TOKEN);

import { REST, Routes, SlashCommandBuilder } from 'discord.js';

const commands = [
  new SlashCommandBuilder().setName('live')
    .setDescription('Show football matches in play right now').toJSON(),
];

const rest = new REST().setToken(process.env.DISCORD_TOKEN);
await rest.put(Routes.applicationCommands(process.env.CLIENT_ID),
  { body: commands });

client.on('interactionCreate', async (i) => {
  if (!i.isChatInputCommand() || i.commandName !== 'live') return;
  await i.deferReply();
  const matches = await goal('/fixtures/live');
  if (!matches.length) return i.editReply('No matches in play right now.');
  const lines = matches.slice(0, 10).map(m =>
    `**${m.homeTeam.name} ${m.homeTeamScore}-${m.awayTeamScore} ${m.awayTeam.name}** ` +
    `· ${m.league.name} · ${m.matchMinute}'`);
  await i.editReply(lines.join('\n'));
});

import { EmbedBuilder } from 'discord.js';

// Goals, cards and substitutions come from three endpoints; merge by minute.
async function matchEmbed(fixtureId) {
  const [goals, cards, subs] = await Promise.all([
    goal(`/fixtures/${fixtureId}/events`),
    goal(`/fixtures/${fixtureId}/cards`),
    goal(`/fixtures/${fixtureId}/substitutions`),
  ]);
  const lines = [
    ...goals.map(g => [g.timeNum, `\u26BD ${g.time}' GOAL — ${g.homeScorer || g.awayScorer} (${g.score})`]),
    ...cards.map(c => [c.timeNum, `${c.card === 'red card' ? '\u{1F7E5}' : '\u{1F7E8}'} ${c.time}' ${c.homeFault || c.awayFault}`]),
    ...subs.map(x => [x.timeNum, `\u{1F504} ${x.time}' ${x.substitution.split('|').map(t => t.trim()).reverse().join(' on for ')}`]),
  ].sort((a, b) => a[0] - b[0]).map(([, line]) => line);

  return new EmbedBuilder()
    .setTitle('Match events')
    .setDescription(lines.join('\n') || 'No events yet')
    .setColor(0x16A34A);
}

import express from 'express';
const app = express();

// Raw body: the signature is computed over the exact bytes we were sent.
app.post('/goal-webhook', express.raw({ type: 'application/json' }), async (req, res) => {
  // 1. verify the X-Goal-Signature header against req.body (see linked guide) — reject if invalid
  const { event, data } = JSON.parse(req.body);
  res.sendStatus(200); // acknowledge fast, then do the work

  if (event === 'goal.scored') {
    // The payload has teams and score; the scorer comes from the events endpoint.
    const goals = await goal(`/fixtures/${data.fixtureId}/events`);
    const last = goals.at(-1);
    const scorer = last ? `${last.homeScorer || last.awayScorer} ${last.time}' ` : '';
    const channel = client.channels.cache.get(TARGET_CHANNEL_ID);
    channel?.send(`\u26BD **GOAL!** ${scorer}— ` +
      `${data.homeTeam} ${data.score.home}-${data.score.away} ${data.awayTeam}`);
  }
});
app.listen(3000);

// A short-lived, single-use token keeps your API key out of the URL
const { token } = await (await fetch(`${BASE}/ws/token`, {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.GOAL_API_KEY}` },
})).json().then(r => r.data);

const ws = new WebSocket(`wss://api.goal-api.com/ws?wsToken=${token}`);
const posted = new Map(); // fixtureId -> goals already announced

ws.addEventListener('open', () => ws.send(JSON.stringify({ type: 'auth', token })));

ws.addEventListener('message', async (ev) => {
  const msg = JSON.parse(ev.data);
  if (msg.type === 'auth_success') {
    // Subscribe to each match you care about (your plan sets how many at once)
    for (const m of await goal('/fixtures/live')) {
      ws.send(JSON.stringify({ type: 'subscribe', resource: 'match', matchId: m.id }));
    }
  }
  if (msg.type === 'match_update') {
    // Each update carries the match's full goal list: announce only the new ones.
    const goals = msg.data.goalscorer ?? [];
    const seen = posted.get(msg.data.id) ?? 0;
    for (const g of goals.slice(seen)) {
      const channel = client.channels.cache.get(TARGET_CHANNEL_ID);
      channel?.send(`\u26BD **GOAL!** ${g.home_scorer || g.away_scorer} (${g.time}') ` +
        `${msg.data.match_hometeam_name} ${g.score} ${msg.data.match_awayteam_name}`);
    }
    posted.set(msg.data.id, goals.length);
  }
});

// /follow <team>  — your DB, your logic
// subscriptions[channelId] = Set of team names
// (webhook payloads name teams as data.homeTeam / data.awayTeam;
//  WebSocket updates as match_hometeam_name / match_awayteam_name)

function shouldPost(channelId, homeTeam, awayTeam) {
  const subs = subscriptions[channelId];
  if (!subs) return false;
  return subs.has(homeTeam) || subs.has(awayTeam);
}

// /table <leagueId>
const table = await goal(`/standings/${leagueId}`);
const rows = table.slice(0, 10).map(r =>
  `${r.overallLeaguePosition}. ${r.team.name} — ${r.overallLeaguePTS} pts`);

// /topscorers <leagueId>
const scorers = (await goal(`/leagues/${leagueId}/top-scorers`))
  .sort((a, b) => a.playerPlace - b.playerPlace)
  .slice(0, 10)
  .map(p => `${p.playerPlace}. ${p.playerName} (${p.teamName}) — ${p.goals}`);