canonical: https://jentic.com/apis/dagpi.xyz/dagpi

# Dagpi Xyz Dagpi API

Dagpi is a fast image manipulation and meme generation API used heavily by Discord bot developers and small creator tools. The API exposes 61 endpoints split across image manipulation, filters, effects, social-media-style overlays, meme templates, and a small data feed of jokes, facts, pickup lines, and other novelty payloads. Authentication is a single API key in the Authorization header; image endpoints accept a source URL parameter and return a transformed image.

## For AI agents

Apply image filters, generate meme overlays, and pull novelty data feeds for Discord bots, creator tools, and lightweight image automations.

## Scope

Does not handle image hosting, video processing, or production CDN delivery - use for transient image manipulation, meme generation, and novelty data feeds only.

## Capabilities

- Apply pixel, blur, sepia, sketch, and other classic filters to a source image
- Generate meme images with overlays such as wanted poster, jail bars, or wasted screen
- Render fake tweet, Discord message, and YouTube comment images for content workflows
- Convert an image to ASCII art, LEGO mosaic, or 3D cube projection
- Produce animated outputs including spinning, glitching, and dissolving GIFs
- Fetch novelty data such as jokes, facts, roasts, pickup lines, and Magic 8-Ball responses

## Use cases

### Discord Bot Image Commands

A Discord bot exposes commands like !pixel, !triggered, and !wanted that take a user's avatar and return a transformed image. The bot calls the matching Dagpi endpoint with the avatar URL and posts the response image back into the channel. With 61 endpoints to choose from, the bot covers a wide library of joke commands without hosting its own image processing pipeline.

Example prompt: On the !pixel command with an avatar URL, call GET `/image/pixel`?url=<avatar> and return the binary response to Discord.

### Social Mockup Generation

Marketing and social teams use Dagpi's `/image/tweet`, `/image/discord`, and `/image/youtube` endpoints to render fake-but-plausible social mockups for slide decks and explainer content. The agent supplies the username, profile picture, and message text, and Dagpi returns a styled image that drops straight into a presentation.

Example prompt: Call GET `/image/tweet` with username, display_name, text, and pfp parameters, and return the resulting image URL.

### Stylised Profile Picture Pipeline

Creator tools that let users transform their profile pictures into stylised variants chain Dagpi endpoints: ASCII art, LEGO mosaic, polaroid frame, neon glow. The agent presents the catalogue of effects, takes the user's choice, and returns the transformed image without the tool needing to ship its own image library.

Example prompt: Given user image URL and chosen effect 'lego', call GET `/image/lego`?url=<image> and return the binary response.

### Agent-Driven Content Filler

An AI agent producing community engagement content pulls jokes, facts, and pickup lines from Dagpi's /data endpoints to seed scheduled posts. Combined with the meme image endpoints, the agent generates an entire post (text plus image) without external content sourcing, which suits low-stakes social channels.

Example prompt: Call GET `/data/joke` for the post body and GET `/image/motiv` with a chosen image and caption for the post visual.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/image/pixel` | Pixelate an image |
| GET | `/image/ascii` | Convert image to ASCII art |
| GET | `/image/wanted` | Create wanted poster |
| GET | `/image/tweet` | Generate fake tweet image |
| GET | `/image/lego` | Convert to LEGO mosaic |
| GET | `/data/joke` | Get a random joke |
| GET | `/data/fact` | Get a random fact |
| GET | `/data/8ball` | Get Magic 8-Ball response |

## Key resources

- **Image Manipulation** — Pixel, mirror, flip, blur, and structural transforms
- **Image Filters** — Sepia, sketch, charcoal, neon, and other artistic filters
- **Image Effects** — Animated glitch, swirl, spin, dissolve, and cube effects
- **Image Memes** — Wanted poster, jail bars, wasted, bonk, and other meme overlays
- **Image Social** — Fake tweet, Discord, YouTube comment, and motivational poster generators
- **Data** — Jokes, facts, roasts, pickup lines, and novelty payloads

## Why Jentic

- **Setup:** Wiring Dagpi by hand means learning its Authorization header token, then wrapping each image and data endpoint with its own request and retry handling yourself. Through Jentic you install once, import the Dagpi API from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Dagpi passes its targets in the request query rather than as resource ids in the path, so limit the agent to the operations it needs, such as applying a pixel filter or generating a tweet image. Every operation the agent can run is one you added to that allowed set.
- **Credential handling:** Your Dagpi Authorization token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'apply an image filter' or 'generate a fake tweet image', and Jentic returns the matching Dagpi operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Cloudinary Upload API** — Production image transformation pipeline with broader format support and CDN delivery.
- **Filestack API** — File processing API with image transformation and upload pipelines.
- **Dagpi data feed** — Dagpi's data endpoints pair with image endpoints for full bot reply generation.

## FAQ

### What authentication does the Dagpi API use?

Dagpi uses an API key passed in the Authorization header. You sign up at dagpi.xyz, generate a token, and include it on every request to api.dagpi.xyz. Through Jentic the token is stored encrypted in the vault and the agent receives a scoped runtime credential, so the key never lands in chat or logs.

### Can I generate a fake tweet image with the Dagpi API?

Yes. GET `/image/tweet` accepts username, display name, text, and profile picture URL parameters and returns a styled fake tweet image. The same pattern applies to `/image/discord` and `/image/youtube` for Discord and YouTube comment mockups.

### What are the rate limits for the Dagpi API?

Dagpi enforces per-token rate limits that vary by plan; the free tier is intentionally constrained for Discord bot use, while paid plans raise the ceiling. The OpenAPI spec does not encode the exact numbers, so check the Dagpi pricing page for the current per-second cap on your plan.

### How do I apply an image filter through Jentic?

Install pip install jentic and run an agent with the search query 'apply an image filter'. Jentic returns the matching Dagpi operation with its input schema, so the agent can call GET `/image/pixel`, `/image/sepia`, or any of the 50+ image endpoints with a source image URL.

### Can I get random jokes or facts from the Dagpi API?

Yes. The /data namespace exposes `/data/joke`, `/data/fact`, `/data/yomama`, `/data/roast`, `/data/pickupline`, `/data/8ball`, and `/data/headline` among others. These return JSON payloads suitable for use as content seeds in bots or scheduled posts.

### Is the Dagpi API free?

Dagpi offers a free tier with limited per-second throughput intended for Discord bot development, and paid tiers that raise the rate limits. The tokens themselves are issued at no cost; the constraint is the rate limit on the free plan.

### Can I limit what my agent is allowed to do with the Dagpi API?

Yes. Because Jentic One is self-hosted, your own rules decide which Dagpi operations the agent may call, so you can allow just the ones a workflow needs, such as GET `/image/pixel` for a filter or GET `/image/tweet` for a fake tweet mockup, and leave the rest off the list. Dagpi passes its target as a URL in the request query rather than as a resource id in the path, so scoping happens at the operation level: every endpoint the agent can run is one you explicitly added to the allowed set. Your Dagpi Authorization token is held by your own instance and injected only at execution time, so the agent never sees the raw key.