Overview

MINTGPT turns a single plain-language idea into a complete, coherent NFT collection and deploys it on Solana. You describe a concept, the app designs the whole system (theme, trait categories, rarity, lore), renders style-consistent art, validates the metadata against the Metaplex schema, and lets your wallet deploy it on-chain as a pre-mint or a public Candy Machine drop with a shareable mint page.

The differentiator is coherence. Most generative collections fall apart the moment you look closely: art styles drift piece to piece, lore does not exist, metadata breaks the listing. MINTGPT is built around consistency, so a collection reads as one world instead of four hundred random guesses. The one-click deploy is the hook; the coherence is what makes a collection worth minting.

Everything is non-custodial. The backend never holds your keys, and you sign and pay for every on-chain action yourself.

Who it is for

• Creators who want a full, coherent collection without a designer, a trait pipeline, or Solana tooling.
• Communities launching a PFP drop that should look like one artist made it.
• Builders who want a fast path from idea to an on-chain, mintable collection with valid metadata.

You do not need to write any code or touch Solidity. You describe an idea and the app handles concept, art, metadata, and the on-chain deploy.

How it works

The pipeline runs in five stages. Each stage is cheap to iterate on before you commit to the expensive one (image generation), and nothing is on-chain until you deploy.

1. 1

   Describe

   One prompt. An LLM designs the theme, trait categories, rarity weights, naming convention, and a style bible.

2. 2

   Preview and refine

   A small sample (around 8 pieces) is assembled from the rarity tables, each with its own lore, then rendered as real art in one locked style. Regenerate any single piece, or scale up to the full collection.

3. 3

   Package

   Every piece gets Metaplex metadata that is validated against the schema before anything is uploaded, then art and metadata go to IPFS.

4. 4

   Deploy

   Your connected wallet signs and pays. Pre-mint the whole collection to yourself, or open a public Candy Machine drop with guards.

5. 5

   List

   On mainnet, Solana collections index on Magic Eden once minted. You claim the collection in the Creator Hub to edit its marketplace page.

Getting started

1. 1

   Connect a wallet

   Use Phantom, Backpack, or Solflare. Nothing is custodial: your keys never leave your wallet, and you sign every on-chain action yourself.

2. 2

   Hold the token (at launch)

   Access is gated by holding a minimum amount of $MINTGPT. Before the token launches the gate is open.

3. 3

   Describe your collection

   Type an idea in plain language, for example Degen apes in streetwear with caps, gold chains and wild sunglasses, then generate the concept.

4. 4

   Preview and generate art

   Review the concept and sample pieces, regenerate anything you do not like, then generate the art in one coherent style.

5. 5

   Package and deploy

   Package the collection (metadata validation plus IPFS upload), then deploy on-chain as a pre-mint or a public drop.

Generation

Generation is split into cheap text steps and one expensive image step, so you validate the direction before spending on art.

Step A: concept design

From your idea, an LLM produces a structured concept: a visual identity, 4 to 6 trait categories with values and rarity weights, a lore narrative, a style bible, a naming convention, and a suggested supply. Rarity weights are relative (higher means more common) and are designed to feel intentional: a few common values, fewer rare ones, and a small number of standout legendaries.

Step B: piece assembly

For each piece, traits are drawn from the rarity tables, a name is generated from the naming convention, and a short lore or description is written that is consistent with the traits and the world. Contradictory trait combinations are avoided so pieces stay believable.

Step C: coherent art

The pieces are rendered as raster art in one locked house style. See the visual coherence section for how consistency is enforced across the whole collection.

Preview, refine, scale

A small sample is generated first so you can validate the style and the rarity balance. When you are happy, generate the full collection at the size you want. Large collections are generated in chunks with bounded concurrency to stay within model rate limits. You can regenerate any single piece at any time.

The concept object

The concept is the coherence backbone that every later step draws from. It is a structured object, roughly shaped like this:

{
  "collectionName": "Grumble Apes",
  "symbol": "GRMBL",
  "theme": "Street-smart apes with attitude...",
  "narrative": "In the back-alleys of Grumble City...",
  "styleBible": {
    "palette": ["#1e1e1e", "#f4c430", "#e24b4a", "#2dd4bf"],
    "mood": "cocky, cold, streetwise",
    "renderingStyle": "hand-drawn bold-ink cartoon, thick outlines, flat colors",
    "constraints": [
      "Thick black ink outlines on every element",
      "3/4 bust portrait, single character, simple background"
    ]
  },
  "traitCategories": [
    {
      "name": "Background",
      "values": [
        { "name": "Alley Teal", "weight": 40, "rarity": "Common" },
        { "name": "Concrete Gray", "weight": 30, "rarity": "Common" },
        { "name": "Neon Grid", "weight": 6,  "rarity": "Rare" }
      ]
    }
  ],
  "namingConvention": "Grumble Ape #001",
  "suggestedSupply": 3333
}

You never edit this JSON by hand. It is shown here so you understand what the model actually designs and why the collection stays coherent: every piece is a sample from the same trait system and style bible.

Visual coherence

Coherence at scale is the hard part of a generative collection, and it is where MINTGPT spends the most effort. Two things keep the art consistent:

A fixed style anchor

Every image prompt is built from the same style bible (palette, mood, rendering style, hard constraints) with only the traits swapped in. Framing and lighting rules are identical across the collection, so the set reads as one world.

A reference image pass

The first piece sets the look. Every other piece is then generated with that first piece passed as a style reference (image-to-image), so palette, linework, character design, and framing carry over. Only the traits change. This is what keeps piece #200 looking like it belongs next to piece #1.

Metadata and storage

Every piece is turned into a Metaplex-compliant metadata JSON and validated against the schema before anything is uploaded. Invalid metadata never reaches the chain, which is what keeps the mint and the marketplace display from breaking. A piece looks like this:

{
  "name": "Grumble Ape #001",
  "symbol": "GRMBL",
  "description": "Brown fur, cap forward, black shades...",
  "image": "https://gateway.pinata.cloud/ipfs/<cid>",
  "attributes": [
    { "trait_type": "Background", "value": "Alley Teal" },
    { "trait_type": "Fur",        "value": "Brown" },
    { "trait_type": "Eyes",       "value": "Black Shades" }
  ],
  "properties": {
    "files": [{ "uri": "<image uri>", "type": "image/webp" }],
    "category": "image"
  }
}

Art and metadata are uploaded to IPFS through Pinata server-side, so the key stays on the server and there is no on-chain funding transaction. If the configured store is a mock, the app falls back to Arweave via Irys, which the connected wallet pays for. Images are compressed to WebP before upload and the uploads are sent in size-safe batches so a large collection never exceeds serverless request limits.

Networks

The app targets one Solana cluster at a time, chosen by configuration.

A deploy on mainnet requires an explicit confirmation in the UI, and a safety guard refuses to run if the selected network and the RPC endpoint disagree (for example a devnet build pointed at a mainnet RPC), so you cannot spend real SOL by accident.

Deploying on Solana

Deployment is non-custodial and wallet-signed. Art and metadata go to IPFS first, then your wallet signs the on-chain transactions. There are two modes.

Pre-mint

The whole collection is minted straight to your wallet as individual pieces (1/1s) using Metaplex Core. Each on-chain create adds a signer, and Solana caps a transaction at 1232 bytes, so pieces are minted in small size-safe batches. The whole batch is approved in a single wallet prompt. If a chunk fails transiently, only that chunk retries, so a hiccup never loses the run.

Public drop (Candy Machine)

Instead of pre-minting, the app stands up a Metaplex Core Candy Machine so the public mints from it. The flow is: create the collection, create the candy machine with its guards, then load the item config lines (name plus metadata URI) in batches. You get a shareable mint page for the drop. Because the public mints the items, the collection has no minted NFTs until someone actually mints.

Candy Machine guards

A public drop can be gated with Candy Guards. MINTGPT exposes the three most common ones when you open a drop:

The mint page reads the live guards from the candy machine, so buyers see the real price, limit, and status, and the on-chain program enforces them at mint time.

The public mint page

Every drop gets its own page at /mint/<candy-machine-address>. Anyone with the link can connect a wallet and mint one item, paying the price and passing the guard checks. The page pulls its content on-chain and from the item metadata:

• The collection name, description, and a cover image.
• A gallery of real sample pieces from the drop.
• Live minted count, price, per-wallet limit, and open or sold-out status.

It is fully non-custodial: the minter signs and pays from their own wallet, and the content degrades gracefully if a gateway is slow so the page never breaks.

Listing on Magic Eden

On mainnet, Solana collections are indexed by Magic Eden once they have minted items on-chain. To take control of the collection page you claim it in the Magic Eden Creator Hub:

1. 1. Enter the collection symbol in the Creator Hub.
2. 2. Sign a verification transaction from the update-authority wallet (the wallet you deployed with).
3. 3. Wait for Magic Eden to approve the ownership transfer.

Indexing is not instant. Right after minting, a brand-new collection can take time to appear, and a Candy Machine drop with zero mints has nothing for Magic Eden to index yet. This step is optional: your collection exists and is mintable on-chain whether or not it is listed on Magic Eden. Creator royalties are optional on Magic Eden, so nothing about the model depends on them.

The $MINTGPT gate

Access uses a token-hold model instead of accounts or card payments: hold at least a set amount of the $MINTGPT SPL token in your wallet to use the app. The balance check is read-only and non-custodial; the app never moves your tokens. You still pay your own on-chain fees when you deploy or mint.

The gate stays open until the real token mint is configured, so the app is usable before the token launches. Once the mint address is set it enforces automatically, and the minimum amount is configurable. The balance is summed across your token accounts for that mint on mainnet.

Configuration

The deployment is configured with environment variables. Values prefixed with NEXT_PUBLIC_ are read at build time and inlined, so they must be set before the build.

Architecture

MINTGPT is a Next.js app. The heavy lifting is split across a few services, and the on-chain stack runs in the browser so signing stays with the user.

The generation endpoints (concept, preview, images, package) run server-side so API keys never reach the browser. The deploy and mint code runs client-side and is dynamically imported, so the heavy Metaplex stack stays out of the initial bundle and the wallet always does the signing.

Safety and constraints

• Non-custodial. The backend never holds your private keys. You sign and pay every on-chain action.
• Solana only. Minting goes through the Metaplex ecosystem. There is no EVM or Solidity.
• Mainnet is irreversible. Validate on devnet and preview before any mainnet mint. The UI asks you to confirm mainnet deploys, and a network guard blocks mismatched RPC endpoints.
• Content moderation. Ideas are screened for real trademarks, protected IP, real people, and disallowed content before generation.
• Valid metadata. Output is validated against the Metaplex schema before upload so listings render correctly the first time.
• Cost control. Art is the expensive step, so a small preview is generated before the full collection, and the full set is only produced when you commit.

Troubleshooting

Network error on the Package step

This means the upload request was too large or timed out. The app compresses images and uploads them in size-safe batches to avoid it. If you still see it right after an update, do a hard refresh (Ctrl+Shift+R) so the browser loads the latest code.

Your wallet shows a warning on the site

Wallets flag new or shared domains that request mainnet signatures. It is a domain-reputation warning, not a bug. Using a custom domain and requesting a review from the wallet provider clears it. For your own testing you can proceed.

Magic Eden says the symbol is not found

The collection is not indexed yet. Make sure at least one item is minted and give Magic Eden time to crawl it, then try the claim again.

Deploy refuses to run on mainnet

The network guard blocks a run when the selected network and the RPC do not match. Point the RPC at the same cluster as the selected network.

FAQ

Glossary