Discord Bot Vote Command Guide

Install:

pip install discord.py aiohttp

import asyncio
import os
        from typing import Any

        import aiohttp
        import discord
        from discord import app_commands
        from discord.ext import commands

        API_BASE_URL = os.getenv("TDS_API_BASE_URL", "https://topdiscordservers.com").rstrip("/")
        API_KEY = os.getenv("TDS_API_KEY", "")
        DISCORD_SERVER_ID = os.getenv("TDS_DISCORD_SERVER_ID", "")


        class Vote(commands.Cog):
          def __init__(self, bot: commands.Bot) -> None:
            self.bot = bot

          @app_commands.command(name="vote", description="Vote for our server")
          async def vote(self, interaction: discord.Interaction) -> None:
            if not API_KEY or not DISCORD_SERVER_ID:
              await interaction.response.send_message(
                "Vote integration is not configured yet.",
                ephemeral=True,
              )
              return

            endpoint = f"{API_BASE_URL}/api/external/discord-servers/{DISCORD_SERVER_ID}/vote"
            payload = {
              "discord_user_id": str(interaction.user.id),
              "direction": "up",
            }
            headers = {
              "Authorization": f"Bearer {API_KEY}",
              "Content-Type": "application/json",
              "Accept": "application/json",
            }

            timeout = aiohttp.ClientTimeout(total=10)
            data: dict[str, Any] = {}
            status = 0

            try:
              async with aiohttp.ClientSession(timeout=timeout) as session:
                async with session.post(endpoint, json=payload, headers=headers) as resp:
                  status = resp.status
                  data = await resp.json(content_type=None)
            except asyncio.TimeoutError:
              await interaction.response.send_message(
                "Vote request timed out. Please try again.",
                ephemeral=True,
              )
              return
            except aiohttp.ClientError:
              await interaction.response.send_message(
                "Vote service is unavailable right now. Please try again later.",
                ephemeral=True,
              )
              return

            if status >= 400:
              message = data.get("message", "Unknown error")
              error_embed = discord.Embed(
                "Vote Failed",
                description=message,
                color=discord.Color.red(),
              )
              error_embed.add_field(name="Status", value=str(status), inline=True)

              if status == 429 and data.get("retryAfterHuman"):
                error_embed.add_field(name="Try Again In", value=str(data["retryAfterHuman"]), inline=True)

              if status == 403 and data.get("registerUrl"):
                error_embed.add_field(name="Register", value=str(data["registerUrl"]), inline=False)

              await interaction.response.send_message(embed=error_embed, ephemeral=True)
              return

            votes = data.get("data", {}).get("votes", "?")
            await interaction.response.send_message(f"Vote recorded. Total votes: {votes}")


        async def setup(bot: commands.Bot) -> None:
          await bot.add_cog(Vote(bot))

import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.awt.Color;

public class VoteCommand {
    private static final String API_KEY = System.getenv("TDS_API_KEY");
    private static final String DISCORD_SERVER_ID = System.getenv("TDS_DISCORD_SERVER_ID");

    public static void handle(SlashCommandInteractionEvent event) throws Exception {
        String url = "https://topdiscordservers.com/api/external/discord-servers/" + DISCORD_SERVER_ID + "/vote";
        String payload = "{\"discord_user_id\":\"" + event.getUser().getId() + "\",\"direction\":\"up\"}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", "Bearer " + API_KEY)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) {
          EmbedBuilder embed = new EmbedBuilder()
            .setTitle("Vote Failed")
            .setDescription("Status " + response.statusCode() + "\\n```json\\n" + response.body() + "\\n```")
            .setColor(Color.RED);
          event.replyEmbeds(embed.build()).setEphemeral(true).queue();
            return;
        }

        event.reply("Vote recorded.").queue();
    }
}

using System.Net.Http;
using System.Text;
using System.Text.Json;
using DSharpPlus.Entities;
using DSharpPlus.SlashCommands;

public class VoteCommands : ApplicationCommandModule
{
    private static readonly HttpClient Http = new HttpClient();
    private static readonly string ApiKey = Environment.GetEnvironmentVariable("TDS_API_KEY");
    private static readonly string DiscordServerId = Environment.GetEnvironmentVariable("TDS_DISCORD_SERVER_ID");

    [SlashCommand("vote", "Vote for our server")]
    public async Task Vote(InteractionContext ctx)
    {
        var url = $"https://topdiscordservers.com/api/external/discord-servers/{DiscordServerId}/vote";
        var body = JsonSerializer.Serialize(new { discord_user_id = ctx.User.Id.ToString(), direction = "up" });

        using var request = new HttpRequestMessage(HttpMethod.Post, url);
        request.Headers.Add("Authorization", $"Bearer {ApiKey}");
        request.Content = new StringContent(body, Encoding.UTF8, "application/json");

        var response = await Http.SendAsync(request);
        var payload = await response.Content.ReadAsStringAsync();
        if (!response.IsSuccessStatusCode)
        {
          string message = "Unknown error";
          string code = "n/a";
          string retryAfterHuman = null;

          try
          {
            using var doc = JsonDocument.Parse(payload);
            var root = doc.RootElement;
            if (root.TryGetProperty("message", out var m)) message = m.GetString() ?? message;
            if (root.TryGetProperty("error_code", out var c)) code = c.GetString() ?? code;
            if (root.TryGetProperty("retryAfterHuman", out var r)) retryAfterHuman = r.GetString();
          }
          catch
          {
            message = payload;
          }

          var embed = new DiscordEmbedBuilder()
            .WithTitle("Vote Failed")
            .WithDescription(message)
            .WithColor(DiscordColor.Red)
            .AddField("Status", ((int)response.StatusCode).ToString(), true)
            .AddField("Code", code, true);

          if ((int)response.StatusCode == 429 && !string.IsNullOrWhiteSpace(retryAfterHuman))
          {
            embed.AddField("Try Again In", retryAfterHuman, true);
          }

          await ctx.CreateResponseAsync(new DiscordInteractionResponseBuilder().AddEmbed(embed), true);
            return;
        }

        await ctx.CreateResponseAsync("Vote recorded.");
    }
}

use GuzzleHttp\Client;

$client = new Client();
$apiKey = getenv('TDS_API_KEY');
$discordServerId = getenv('TDS_DISCORD_SERVER_ID');

$response = $client->post("https://topdiscordservers.com/api/external/discord-servers/{$discordServerId}/vote", [
    'headers' => [
        'Authorization' => 'Bearer '.$apiKey,
        'Accept' => 'application/json',
    ],
    'json' => [
        'discord_user_id' => (string) $discordUserId,
        'direction' => 'up',
    ],
]);

$payload = json_decode((string) $response->getBody(), true);

package main

import (
  "bytes"
  "net/http"
  "os"
)

func vote(discordUserID string) (*http.Response, error) {
  discordServerID := os.Getenv("TDS_DISCORD_SERVER_ID")
  apiKey := os.Getenv("TDS_API_KEY")
  body := []byte(`{"discord_user_id":"` + discordUserID + `","direction":"up"}`)

  req, _ := http.NewRequest("POST", "https://topdiscordservers.com/api/external/discord-servers/"+discordServerID+"/vote", bytes.NewBuffer(body))
  req.Header.Set("Authorization", "Bearer "+apiKey)
  req.Header.Set("Content-Type", "application/json")
  req.Header.Set("Accept", "application/json")

  client := &http.Client{}
  return client.Do(req)
}

curl -X POST "https://topdiscordservers.com/api/external/discord-servers/123456789012345678/vote" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"discord_user_id":"123456789012345678","direction":"up"}'