Developer API - CUB SOFTWARE

Base URL

Base https://cubsoftware.site

Authentication

No API key required — all listed endpoints are publicly accessible.

Please include a descriptive User-Agent header identifying your app.

Meme API

GET /api/memes/{category} Fetch a random meme

Returns a random meme from the specified category. Results are always SFW and non-spoiler filtered.

Parameter	Type	Required	Description
category	string	optional	Meme category (see list below). Defaults to `random` if omitted.

Example Response

"url":      "https://i.redd.it/abc123.jpg",
"title":    "When the code works first try",
"text":     null,
"type":     "image",  // "image" | "text"
"category": "programmer",
"author":   "CUBSOFTWARE"

curl https://cubsoftware.site/api/memes/dank
const res = await fetch('https://cubsoftware.site/api/memes/dank');
const meme = await res.json();
console.log(meme.url, meme.title);
const https = require('https');

https.get('https://cubsoftware.site/api/memes/dank', (res) => {
    let data = '';
    res.on('data', chunk => data += chunk);
    res.on('end', () => {
        const meme = JSON.parse(data);
        console.log(meme.url, meme.title);
    });
});
import requests

res = requests.get('https://cubsoftware.site/api/memes/dank')
meme = res.json()
print(meme['url'], meme['title'])
<?php
$res  = file_get_contents('https://cubsoftware.site/api/memes/dank');
$meme = json_decode($res, true);
echo $meme['url'] . ' — ' . $meme['title'];
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "io"
)

func main() {
    resp, _ := http.Get("https://cubsoftware.site/api/memes/dank")
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var meme map[string]any
    json.Unmarshal(body, &meme)
    fmt.Println(meme["url"], meme["title"])
}
using System.Net.Http.Json;

var client = new HttpClient();
var meme = await client.GetFromJsonAsync<Dictionary<string, object>>(
    "https://cubsoftware.site/api/memes/dank"
);
Console.WriteLine($"{meme["url"]} — {meme["title"]}");
import java.net.URI;
import java.net.http.*;
import com.fasterxml.jackson.databind.ObjectMapper;

var client = HttpClient.newHttpClient();
var req    = HttpRequest.newBuilder()
    .uri(URI.create("https://cubsoftware.site/api/memes/dank"))
    .build();
var res  = client.send(req, HttpResponse.BodyHandlers.ofString());
var meme = new ObjectMapper().readValue(res.body(), Map.class);
System.out.println(meme.get("url"));
require 'net/http'
require 'json'

uri  = URI('https://cubsoftware.site/api/memes/dank')
meme = JSON.parse(Net::HTTP.get(uri))
puts meme['url'], meme['title']

GET /api/memes/categories List all categories

Returns a sorted list of all valid category names.

Example Response

"categories": [
  "animals", "anime", "based", "boomer", "car", "cat", 
  "chess", "cringe", "cursed", "dad", "dank", "dark", 
  "deep-fried", "dog", "engineering", "fallout", "food", "gaming", 
  "genshin", "genz", "gif", "history", "irl", "linux", 
  "lotr", "math", "medical", "minecraft", "music", "npc", 
  "office", "pokemon", "programmer", "pun", "random", "reaction", 
  "roblox", "science", "shitpost", "skull", "skyrim", "space", 
  "spongebob", "sports", "starwars", "superhero", "surreal", "trending", 
  "twitter", "valorant", "vibe", "wholesome"
]

GET /api/memes Random meme (no category)

Shorthand for /api/memes/random — picks from the best subreddits automatically.

Discord Bot Examples

Drop-in examples for adding a /meme slash command to your Discord bot using the CUB SOFTWARE API. Each example registers the command and sends the image — copy, paste, add your token.

// npm install discord.js
const { Client, GatewayIntentBits, SlashCommandBuilder, EmbedBuilder } = require('discord.js');

const client = new Client({ intents: [GatewayIntentBits.Guilds] });

client.once('ready', async () => {
    await client.application.commands.create(
        new SlashCommandBuilder()
            .setName('meme')
            .setDescription('Get a random meme')
            .addStringOption(o => o
                .setName('category')
                .setDescription('Meme category (optional)')
                .setRequired(false))
    );
    console.log('Ready!');
});

client.on('interactionCreate', async interaction => {
    if (!interaction.isChatInputCommand() || interaction.commandName !== 'meme') return;
    await interaction.deferReply();

    const category = interaction.options.getString('category') || 'random';
    const res  = await fetch(`https://cubsoftware.site/api/memes/${category}`);
    const meme = await res.json();

    if (meme.type === 'text') {
        const embed = new EmbedBuilder()
            .setTitle(meme.title)
            .setDescription(meme.text)
            .setColor(0x5865F2);
        return interaction.editReply({ embeds: [embed] });
    }
    const embed = new EmbedBuilder()
        .setImage(meme.url)
        .setColor(0x5865F2);
    return interaction.editReply({ embeds: [embed] });
});

client.login('YOUR_BOT_TOKEN');
# pip install discord.py aiohttp
import discord
from discord import app_commands
import aiohttp

intents = discord.Intents.default()
client  = discord.Client(intents=intents)
tree    = app_commands.CommandTree(client)

@tree.command(name="meme", description="Get a random meme")
@app_commands.describe(category="Meme category (optional)")
async def meme(interaction: discord.Interaction, category: str = "random"):
    await interaction.response.defer()
    async with aiohttp.ClientSession() as s:
        async with s.get(f"https://cubsoftware.site/api/memes/{category}") as r:
            data = await r.json()

    embed = discord.Embed(color=0x5865F2)
    if data["type"] == "text":
        embed.title       = data["title"]
        embed.description = data["text"]
    else:
        embed.set_image(url=data["url"])
    await interaction.followup.send(embed=embed)

@client.event
async def on_ready():
    await tree.sync()
    print(f"Logged in as {client.user}")

client.run("YOUR_BOT_TOKEN")
// build.gradle: implementation 'net.dv8tion:JDA:5.x.x'
import net.dv8tion.jda.api.*;
import net.dv8tion.jda.api.events.interaction.command.*;
import net.dv8tion.jda.api.hooks.*;
import net.dv8tion.jda.api.interactions.commands.*;
import net.dv8tion.jda.api.EmbedBuilder;
import java.net.http.*;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;

public class MemeBot extends ListenerAdapter {
    static final ObjectMapper JSON = new ObjectMapper();
    static final HttpClient    HTTP = HttpClient.newHttpClient();

    @Override
    public void onSlashCommandInteraction(SlashCommandInteractionEvent e) {
        if (!e.getName().equals("meme")) return;
        e.deferReply().queue();
        String cat = e.getOption("category") != null
            ? e.getOption("category").getAsString()
            : "random";
        try {
            var req  = HttpRequest.newBuilder()
                .uri(URI.create("https://cubsoftware.site/api/memes/" + cat))
                .build();
            var body = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body();
            var meme = JSON.readTree(body);
            var embed = new EmbedBuilder().setColor(0x5865F2);
            if ("text".equals(meme.get("type").asText())) {
                embed.setTitle(meme.get("title").asText())
                     .setDescription(meme.get("text").asText());
            } else {
                embed.setImage(meme.get("url").asText());
            }
            e.getHook().editOriginalEmbeds(embed.build()).queue();
        } catch (Exception ex) {
            e.getHook().editOriginal("❌ Couldn't grab a meme right now.").queue();
        }
    }

    public static void main(String[] args) throws Exception {
        JDABuilder.createDefault("YOUR_BOT_TOKEN")
            .addEventListeners(new MemeBot())
            .build().upsertCommand("meme", "Get a random meme").queue();
    }
}
// dotnet add package Discord.Net
using Discord;
using Discord.WebSocket;
using System.Net.Http.Json;
using System.Text.Json;

var client = new DiscordSocketClient();
var http   = new HttpClient();

client.SlashCommandExecuted += async cmd => {
    if (cmd.CommandName != "meme") return;
    await cmd.DeferAsync();
    var cat  = cmd.Data.Options
        .FirstOrDefault(o => o.Name == "category")?.Value?.ToString() ?? "random";
    var meme = await http.GetFromJsonAsync<JsonElement>(
        $"https://cubsoftware.site/api/memes/{cat}");
    var embed = new EmbedBuilder().WithColor(0x5865F2);
    if (meme.GetProperty("type").GetString() == "text") {
        embed.WithTitle(meme.GetProperty("title").GetString())
             .WithDescription(meme.GetProperty("text").GetString());
    } else {
        embed.WithImageUrl(meme.GetProperty("url").GetString());
    }
    await cmd.FollowupAsync(embed: embed.Build());
};

client.Ready += async () => {
    await client.CreateGlobalApplicationCommandAsync(
        new SlashCommandBuilder()
            .WithName("meme")
            .WithDescription("Get a random meme")
            .Build());
};

await client.LoginAsync(TokenType.Bot, "YOUR_BOT_TOKEN");
await client.StartAsync();
await Task.Delay(-1);

Want /meme dank, /meme cat etc. as separate subcommands?

Instead of a string option, register each category as its own subcommand. Replace the command registration in the examples above with the snippet below, then read getSubcommand() / interaction.data.options[0].name in your handler instead of getString('category').

const CATEGORIES = [
    'random', 'dank', 'dark', 'wholesome', 'cursed', 'gaming',
    'programmer', 'genz', 'surreal', 'anime', 'cat', 'dog',
    'shitpost', 'deep-fried', 'pun', 'dad', 'twitter', 'vibe',
    'based', 'skull', 'cringe', 'boomer', 'npc', 'trending', 'irl'
];

// Replace the commands.create() call with this:
const cmd = new SlashCommandBuilder().setName('meme').setDescription('Get a meme');
for (const cat of CATEGORIES) {
    cmd.addSubcommand(sub => sub.setName(cat).setDescription(`Get a ${cat} meme`));
}
await client.application.commands.create(cmd);

// In your handler, replace getString('category') with:
const category = interaction.options.getSubcommand();
CATEGORIES = [
    'random', 'dank', 'dark', 'wholesome', 'cursed', 'gaming',
    'programmer', 'genz', 'surreal', 'anime', 'cat', 'dog',
    'shitpost', 'deep-fried', 'pun', 'dad', 'twitter', 'vibe',
    'based', 'skull', 'cringe', 'boomer', 'npc', 'trending', 'irl'
]

# Replace the @tree.command block with a group + loop:
meme_group = app_commands.Group(name="meme", description="Get a meme")

def _register(cat):
    @meme_group.command(name=cat, description=f"Get a {cat} meme")
    async def _cmd(interaction: discord.Interaction):
        await meme(interaction, cat)  # reuse your existing handler

for cat in CATEGORIES:
    _register(cat)

tree.add_command(meme_group)
import net.dv8tion.jda.api.interactions.commands.build.*;
import java.util.List;

static final List<String> CATS = List.of(
    "random", "dank", "dark", "wholesome", "cursed", "gaming",
    "programmer", "genz", "surreal", "anime", "cat", "dog",
    "shitpost", "deep-fried", "pun", "dad", "twitter", "vibe",
    "based", "skull", "cringe", "boomer", "npc", "trending", "irl"
);

// Replace upsertCommand("meme", ...) with:
var cmd = Commands.slash("meme", "Get a meme");
for (String cat : CATS) {
    cmd.addSubcommands(new SubcommandData(cat, "Get a " + cat + " meme"));
}
jda.upsertCommand(cmd).queue();

// In your handler, replace getOption("category") with:
String cat = e.getSubcommandName();
var CATS = new[] {
    "random", "dank", "dark", "wholesome", "cursed", "gaming",
    "programmer", "genz", "surreal", "anime", "cat", "dog",
    "shitpost", "deep-fried", "pun", "dad", "twitter", "vibe",
    "based", "skull", "cringe", "boomer", "npc", "trending", "irl"
};

// Replace CreateGlobalApplicationCommandAsync with:
var cmd = new SlashCommandBuilder().WithName("meme").WithDescription("Get a meme");
foreach (var cat in CATS) {
    cmd.AddOption(new SlashCommandOptionBuilder()
        .WithName(cat).WithDescription($"Get a {cat} meme")
        .WithType(ApplicationCommandOptionType.SubCommand));
}
await client.CreateGlobalApplicationCommandAsync(cmd.Build());

// In your handler, replace the Options lookup with:
var cat = ((SocketSlashCommandDataOption)cmd.Data.Options.First()).Name;

Playground

Pick a category and fetch a real meme right now.

Fair Use

10 requests / second per IP. Exceeding this returns HTTP 429.

All results are SFW and non-spoiler filtered.

Coming Soon

More APIs are planned. Check back — we'll document everything here as it ships.