ChainGPT AI NFT Generator QuickStart Guide

This QuickStart walks you through generating AI images and minting NFTs using ChainGPT’s API and SDK — with real examples, valid parameters, and everything you need to go live fast.

Prerequisites

Before you begin, make sure you have the following in place:

• ChainGPT API Key: Sign up on the ChainGPT platform and obtain an API key from the API dashboard. Every request must include this key in the Authorization header (as a Bearer token). Also ensure your account has sufficient credits (see Pricing & Credits below) – requests will fail if you run out of credits.

• Node.js Environment: Install (for using the SDK). You’ll also need a package manager like npm or Yarn.

• API Access Tool: For making raw API calls, you can use cURL (as shown in examples) or any HTTP client (Postman, etc.). All API endpoints are relative to the base URL https://api.chaingpt.org.

Using the REST API (via cURL)

ChainGPT’s AI NFT Generator API allows you to generate AI images from text and optionally mint them as NFTs. Below we demonstrate the workflow using direct REST calls with cURL.

1. Generate an AI Image (Synchronous)

To generate an image from a text prompt, use the POST /nft/generate-image endpoint. This returns the image data directly in the response, suitable for quick previews or standalone image generation.

Request: Include your API key in the header and provide the prompt and generation parameters in JSON. For example:

In this request:

• prompt – The text description of the image to generate.

• model – The AI model to use (e.g. "velogen", "nebula_forge_xl", "VisionaryForge", or "Dale3" for DALL·E 3).

Response: On success, you’ll get a JSON response with the image data. For example:

The data field is an array of bytes representing the generated image (in this case, a JPEG). You can convert this to an image file. For instance, in Node.js you could do:

This will write the bytes to output.jpg. (If the API returns a base64 string instead, decode it accordingly.)

Model Options & Parameters: The API supports multiple models, each with different capabilities:

• velogen – Fast generation for smaller images. Supports base resolutions up to ~768px and 1–4 steps (quick iterations).

• nebula_forge_xl – High-quality model for larger images (up to 1024px) and more steps (up to 50 for fine detail).

• VisionaryForge – Similar to Nebula Forge XL (up to 1024px, 50 steps), with its own style/profile.

• Dale3 – Integration of OpenAI’s DALL·E 3 model. Fixed 1024×1024 output, no custom steps or enhancements allowed. Use this for DALL·E’s unique output, but note it has a separate pricing structure (see below).

Each model has recommended resolution ranges. For example, velogen is optimal at 512–768px (can upscale to ~1920px with enhance: "2x"), whereas Nebula/VisionaryForge excel at 768–1024px (up to ~1536px with upscale). If you request a resolution beyond a model’s base capability without setting enhance, the API may automatically upscale it if possible. It’s best to explicitly use the enhance parameter if you want high resolution output.

2. Queue an NFT Image Generation (Asynchronous)

If you intend to mint the image as an NFT, it’s recommended to use the queued generation endpoint. This allows the backend to handle longer-running jobs and prepare NFT metadata. Use POST /nft/generate-nft-queue to start the generation without waiting for the image immediately.

Request: In addition to the prompt and image settings, you must provide:

• walletAddress – The blockchain wallet address that will ultimately receive/own the NFT.

• chainId – The identifier of the blockchain network where the NFT will be minted. (Use the Get Chains endpoint or see below for how to find supported chain IDs.)

Example cURL to queue a generation:

This request queues an image generation with the given parameters (prompt, model, etc.) on BSC Mainnet (chainId: 56). Higher values for steps (like 25 or even 50 for Nebula) can yield very detailed images, and here we used enhance: "2x" for an upscaled 1024→1536px output.

Response: The server immediately returns a job identifier:

The collectionId is a unique UUID for this generation task. The status will initially be "queued" (or "processing" shortly after) – no image is returned yet. You will use this ID to query the generation status and later to mint the NFT.

3. Check Generation Progress

After queueing an NFT generation, you can poll its status using GET /nft/progress/{collectionId}. This returns the current status and (if completed) the result of the generation.

For example:

Response: If the job is still in progress, you’ll see something like:

Here, status is "processing" and progress is ~45%. (Some jobs may not return a percentage, just a status.) When the status becomes "completed", the response will include the image data:

In the above completed example, data contains the bytes of the generated image (starting with 137 80 78 71 which is the PNG file signature). You can now save or utilize this image (just as in step 1).

Often, instead of manually retrieving the raw image here, the next step is to call the minting API to get the NFT metadata. The image is stored on the backend once generation completes. For simplicity, you can proceed directly to Mint the NFT after you see a "completed" status.

Tip: You don’t have to query progress in a tight loop. Polling every few seconds is sufficient. Alternatively, you could implement a webhook/callback if the API provided one, but polling is straightforward for most use cases.

4. (Optional) Enhance a Text Prompt

If you have a short or less-detailed prompt and want to improve it before generating an image, you can use POST /nft/enhancePrompt. This endpoint uses AI to refine your prompt (making it more descriptive or creative), which can lead to better image outcomes.

For example:

Response:

The API returns an enhancedPrompt field containing a more detailed version of your input. You can then take this suggestion and use it as the prompt in your next generate-image or generate-nft-queue call. Each prompt enhancement call costs a small number of credits (0.5 credits per call).

(Using prompt enhancement is optional but recommended if you’re not getting the desired detail in the outputs. It can help maximize the quality of the image, especially for expensive models or high-step generations.)

5. Retrieve Supported Blockchains (Get Chains)

The AI NFT Generator supports minting on multiple blockchain networks. To see which chainId values you can use, call GET /nft/get-chains:

By default, this returns only mainnets. Add ?testNet=true to include test networks. A sample response:

Each entry has a chainId and name. Use these IDs in the generation and minting calls. For example, 56 for Binance Smart Chain, 1 for Ethereum, 137 for Polygon, etc. If you’re testing on a testnet (like BSC Testnet or Goerli), be sure to both use the testnet chainId and a wallet address from that test network.

6. Mint the NFT (Finalize Metadata & Minting)

Once your image is generated (and you have a collectionId from the queued generation), the final step is to mint the NFT. This involves calling POST /nft/mint-nft with the collectionId and some NFT metadata. This call will prepare the NFT’s metadata (and potentially trigger the on-chain mint, depending on the setup).

Request: Provide:

• collectionId – The ID from the completed generation job (ensure the status was “completed” before minting).

• name – A name/title for the NFT (e.g. "Neon Skyline City").

• description – A description for the NFT, detailing the artwork or any info you want in the token metadata.

Example cURL:

Response: If successful, you will receive metadata about the newly created NFT. For example:

This includes the name, description you provided, and importantly an image URL (often an IPFS link to the image that was uploaded). Additional metadata like attributes could appear if relevant. The transaction field may contain a transaction hash if the system initiated an on-chain mint for you, or null if not applicable.

At this point, the NFT’s data is ready. If the service did not automatically mint the NFT on-chain, you have two options to finalize the minting:

• Use the ChainGPT NFT contract to mint the token to the provided wallet address (you'll need on-chain interaction, see Contract ABI below).

• Or, if transaction was returned, wait for that transaction to confirm on-chain (or fetch it via a blockchain explorer).

In most cases, you will need to perform the actual blockchain transaction yourself. The mint-nft response gives you the metadata (and the image is now pinned e.g. on IPFS). Now you or your backend can call the blockchain smart contract’s mint function to create the NFT.

7. (Optional) Get the NFT Contract ABI

If you plan to interact with the NFT smart contract directly (to manually call the mint function, or to integrate with web3 tooling), you can fetch the contract’s ABI via GET /nft/abi. This returns the ABI (Application Binary Interface) JSON of the ChainGPT NFT Mint Factory contract.

Example:

Response:

This ABI JSON can be used with a web3 library (Ethers.js, Web3.py, etc.) to invoke the contract. Typically, the NFT contract has a mint(address to, string tokenURI) function you’ll call, passing the walletAddress and a token URI (which the backend has likely already created for you, pointing to the metadata JSON). The ABI also defines events like NFTMinted that you could listen for.

Using the ABI from the API ensures you’re interacting with the correct contract and function signature. After calling mint-nft (Step 6), you would use this ABI along with the collectionId/metadata info to execute an on-chain transaction to actually mint the NFT to the user’s wallet.

Using the Node.js SDK (@chaingpt/nft)

ChainGPT provides an official JavaScript/TypeScript SDK (@chaingpt/nft on npm) to simplify integration. This SDK wraps all the above API calls into convenient functions. In this section, we’ll accomplish the same tasks using Node.js.

1. Installation and Setup

First, install the SDK into your Node.js project:

Import and initialize the SDK in your code with your API key:

Here we store the API key in an environment variable for safety (you can replace process.env.CHAINGPT_API_KEY with your key string for testing, but avoid hardcoding secrets in production). The Nft class instance nft will be used to call all NFT API methods.

2. Generate an Image using the SDK

To generate an image, use the nft.generateImage() method. This mirrors the POST /nft/generate-image endpoint.

A few notes on the above code:

• The parameters prompt, model, steps, height, width, enhance are the same as described in the REST API section and are passed in as an object. The values here will produce a 512×512 image using the velogen model with 2 refinement steps and a 1× enhancement (effectively upscaled from 256px base to 512px output, since velogen’s base resolution is smaller).

• imageResult

This method is synchronous from the caller’s perspective (it awaits the image generation to complete and returns the image). Use this for quick generation or when you need the image immediately.

Model options and parameters (as discussed earlier) apply here as well. For example, you could switch model to "nebula_forge_xl" and increase steps to 25 for a higher-quality image (just ensure to adjust height/width within that model’s range, e.g. 1024×1024, and consider using enhance: "2x" for maximum quality). The SDK will call the appropriate API and retrieve the result.

3. Get Supported Chains (Networks)

You can retrieve the list of supported blockchains via the SDK using nft.getChains(). By default, getChains() returns mainnets; pass true to include testnets.

This will fetch the same data as the /nft/get-chains API. Each call returns an object containing a chains array (accessible via .data in the SDK response). For example, chainsMainnet.data.chains might include entries like { chainId: 56, name: 'BSC Mainnet', ... }. Use these IDs for the chainId parameter in generation and minting.

4. Generate an NFT (Image + Metadata) using the SDK

To generate an image with the intent to mint it as an NFT, you have two options in the SDK:

• Immediate generation with nft.generateNft(): This will wait for the image generation to complete and return the image data plus a collectionId. Use this if your application can afford to wait (e.g. 30-60 seconds) for the generation to finish in one go.

• Queued generation with nft.generateNftWithQueue(): This will return immediately with a collectionId (similar to the REST generate-nft-queue), and you can then poll progress with nft.getNftProgress()

For simplicity, here’s how to use generateNft() for a synchronous flow:

This call will take some time to resolve (it internally queues the generation and waits for completion). Once it returns, you get an object result containing the image data and a collectionId. We log the collectionId for reference. At this point, the image is generated and stored, and you can proceed to mint it.

If instead you prefer to not block execution, you could use generateNftWithQueue():

This returns immediately with the collectionId. You can then call nft.getNftProgress({ collectionId }) in intervals to check status and progress, similar to the REST polling in step 3. The usage of getNftProgress is straightforward:

It will output the status ("queued", "processing", or "completed") and progress percent if available. Once completed, you could retrieve the image (though if you plan to immediately mint, you might skip directly retrieving the raw image and just call mintNft as shown next).

5. Enhance a Prompt via SDK (Optional)

To use the prompt enhancement feature through the SDK, call nft.enhancePrompt():

This will return an object whose data.enhancedPrompt is the improved prompt text (just like the REST response). You can then use that string in generateImage or generateNft calls to potentially get better results. Each call costs ~0.5 credits.

6. Mint the NFT (using the SDK)

After generating the NFT (and obtaining a collectionId), use the SDK’s nft.mintNft() method to retrieve the minting details and finalize the NFT.

In this snippet, replace collectionId with the ID from the generation step (e.g. result.data.collectionId from generateNft() earlier). The mintNft call requires the same three metadata fields: name, description, symbol. On success, mintRes.data will contain the NFT metadata and possibly a transaction reference, similar to the REST response. You should see the image URL (likely an IPFS link) and the collectionId echoed back. If the SDK/backend initiated an on-chain mint, a transaction hash might be present in the data; if not, you’ll use the ABI to mint manually.

After this, the NFT’s metadata is on-chain or ready to be minted on-chain. If no auto-mint happened, the next step would be using a blockchain library to call the actual smart contract’s mint function, as described below.

7. Get the NFT Contract ABI (SDK)

You can fetch the NFT contract’s ABI via the SDK as well with nft.abi():

This returns the same JSON ABI that the REST call would. You can use this output in your web3 interactions. For example, with Ethers.js you might do:

Where tokenURI is the metadata URL (e.g. the IPFS link) you got from mintNft(). The exact contract address to use would be provided by ChainGPT’s documentation for each chain (or possibly returned in the mint response or available in the getChains data if a new contract is deployed per chain).

Pricing & Credit Usage

ChainGPT’s NFT Generator API uses a credit system. Each API call deducts credits from your balance, so you should understand the costs:

• Standard image generation (ChainGPT models): Using models like velogen, nebula_forge_xl, or VisionaryForge costs 1 credit per image at base resolution. If you use enhancement ("1x" or "2x"), it costs 2 credits per image (effectively +1 credit for the upscale). For example, generating a 1024×1024 image with Nebula Forge XL will cost 1 credit, and if you set enhance: "1x" (HD upscale), it will cost 2 credits.

Make sure you have enough credits for the operations you plan to run. For example, a single generateNft with Nebula (no enhance) will use 1 credit, plus a mintNft call (0 credits) – total 1 credit. The same with DALL·E 3 might use ~4.75 credits. If you plan to generate many images or use upscale frequently, ensure your credit balance is topped up accordingly.

Error Handling

Both the REST API and SDK provide error information to help you diagnose issues:

• HTTP Status Codes: The REST API returns standard codes. A 200 OK indicates success (image or job created). 400 Bad Request means something was wrong with your request (e.g., missing required field or invalid parameter value). For instance, if you exceed a model’s resolution limits, you might get a 400 with an error message like {"error": "height and width exceed allowed resolution for model velogen"}. 401 Unauthorized means your API key is missing/invalid, or you’ve run out of credits – check that you included the correct Bearer token and have sufficient credits. 429 Too Many Requests indicates you hit a rate limit or tried to use the API with no credits (the service may also treat no-credit attempts as a form of rate limit). 500 Internal Server Error is a rare server-side issue – you can retry after a delay or contact support if it persists. The error responses typically include a JSON body with an "error"

Supported Styles

Here is a list of supported models:

3d-model

analog-film

anime

cinematic

comic-book

digital-art

enhance

fantasy-art

isometric

line-art

low-poly

neon-punk

origami

photographic

pixel-art

texture

craft-clay

Next Steps and Additional Resources

You have now generated AI-driven images and minted an NFT using ChainGPT’s API and SDK. From here, you can integrate these calls into your application’s backend or frontend. For a more in-depth understanding of each endpoint and method, refer to the official ChainGPT AI NFT Generator API Reference and SDK Reference documentation. These resources provide detailed descriptions of all parameters, more example scenarios, and information on advanced features.

For any questions or support, check out the ChainGPT community channels or contact the team as listed on the ChainGPT website. Happy building your NFT application with ChainGPT’s AI NFT Generator!

ChainGPT AI NFT Generator (API & SDK) Overview

ChainGPT’s AI NFT Generator is a full-stack API and SDK for creating, minting, and managing NFTs through AI. It’s the first solution to combine AI-driven image generation with on-chain NFT minting in one platform, so developers can go from an idea to a blockchain asset seamlessly. With a single integration, you can generate unique images from text prompts, convert them into NFT metadata, and mint them on multiple blockchains – all without needing separate AI models or smart contract code​. This empowers developers, product teams, and Web3 projects to launch NFT features faster, using ChainGPT’s infrastructure to handle the heavy lifting.

Key Use Cases

• Single NFT Generation: Create one-off AI-generated NFTs on demand. For example, users in a game or app can input a prompt to instantly get a custom NFT avatar or digital collectible. The API returns the generated image and token data, ready to mint or display.

• Full Collection Creation: Generate entire NFT collections (up to 10,000 images) in one go​. The AI can produce large sets of art with variation, which you can mint as a series (e.g. generative profile picture collections). This dramatically speeds up launching an NFT project – what used to take weeks of manual design can happen in under a minute.

• Integrated Minting: Every image comes with mint-ready metadata. You can directly mint the AI-generated art as an NFT on the chosen blockchain via the API/SDK, without writing custom smart contracts. The service handles token creation, storage of the image/metadata, and linking it all on-chain.

How It Works

The process starts with a text prompt provided by the developer or user, describing the desired artwork. The AI model then generates an image based on this prompt (using advanced text-to-image algorithms). Next, the system creates an NFT metadata JSON for the image – including details like title, description, and any traits, plus a link to the image file. With one API call, the platform mints a new NFT token on the specified blockchain, attaching the generated image and metadata to it. Finally, your NFT collection can be added to your wallet and used as you wish! All these steps are orchestrated behind a single API/SDK interface, so you don’t need to manage them separately.

Integration Options: API vs SDK

ChainGPT offers both a RESTful API and a client SDK, so you can choose the integration path that fits your stack:

• REST API: Integrate via HTTP endpoints accessible in any language or platform. This option is ideal if you want direct control or are working in a backend environment outside of Node.js. You send requests with the prompt, parameters, and target chain, and receive the generated image/metadata or transaction details in JSON responses. (If you only need image generation without minting, a lightweight text-to-image API endpoint is available as well.) See the API Reference for full endpoint details and examples.

• JavaScript/TypeScript SDK: Use ChainGPT’s official SDK package for Node.js projects. The SDK provides convenient methods that wrap the API calls – for example, generateImage() or generateNft() – abstracting away raw HTTP calls and handling tasks like file I/O. It’s well-suited for frontend web apps, Node backends, or scripts, and includes TypeScript type definitions for safer development. The SDK simplifies common workflows (such as queuing batch jobs or tracking generation progress) with one-line function calls. Refer to the SDK Reference for installation and code snippets.

Supported Blockchains

One of the AI NFT Generator’s strengths is broad multichain support. Out of the box, you can mint NFTs on a wide range of networks without any custom setup. Supported chains include:

• Ethereum – Mainnet and testnets

• Binance Chain (BNB) – and opBNB layer 2

• Polygon (Ethereum sidechain)

• Arbitrum One and other L2s

In total, 25+ blockchain networks are integrated. The API/SDK uses a simple chainId parameter to select the target network, so switching the mint destination (or offering a choice to your users) is straightforward. ChainGPT handles the low-level differences between chains, providing a unified NFT minting experience across ecosystems.

Unique Capabilities

ChainGPT’s AI NFT Generator comes with several powerful features that distinguish it from basic image APIs:

• Prompt Enhancement & Suggestions: To help improve results, the platform includes an “Enhance Prompt” option that refines your input text for a better image output. There’s also a “Surprise Me” feature that suggests random creative prompts, which can inspire users or generate diverse outputs without extra input. These tools lower the barrier for non-artists to get high-quality NFTs.

• Batch Queueing for Collections: When generating large collections, you can use the queue system to process images asynchronously. Rather than waiting on one NFT at a time, the SDK allows queuing up generation tasks (e.g. generateNftWithQueue() in the SDK) so you can request hundreds or thousands of images in parallel​file-leehq5gwmzjy2dqf8wha2q. The API provides methods to check generation progress and retrieve results when ready, enabling scalable NFT creation workflows.

Developer-Friendly Design

The AI NFT Generator API & SDK are built with developers in mind, focusing on quick integration and robust performance:

• Fast & Efficient: Generation and minting are optimized for low latency. In typical cases, an NFT (image + on-chain mint) can be produced in 30–60 seconds. Even bulk operations use parallel processing and queueing to finish quickly. This speed lets you integrate on-demand NFT creation in real time applications (like letting a user design an NFT and mint it during a sign-up flow) without long waits.

• No AI/ML Expertise Needed: You don’t have to train models or manage machine learning pipelines. ChainGPT’s models are pre-trained and continuously improved by the team, so you simply leverage them via API. There’s no need for you to gather datasets, run GPU servers, or tweak neural network parameters – the service delivers great results out-of-the-box.

• Customizable Outputs: While the default settings work for most cases, developers can fine-tune the generation process through parameters. You can adjust the diffusion steps

Next Steps

• Quickstart Guide: Follow the step-by-step Quickstart to create your first AI-generated NFT using the API/SDK. This guide covers setting up your API key, making a test generation call, and minting a sample NFT (ideal for newcomers).

• API Reference: Refer to the API reference for a complete list of endpoints, parameters, and response schemas. Each feature (image generation, minting, etc.) is documented with example requests and responses to help you build correctly.

• SDK Reference: Check out the SDK documentation for usage of the JavaScript/TypeScript library. It includes code snippets for all major functions (generate image, mint NFT, queue jobs, etc.) and best practices for integrating the SDK into your project.

• Pricing & Credits: ChainGPT’s AI NFT Generator API uses a simple and transparent credit system. Each API request consumes credits based on the model selected, generation options, and image resolution. Learn more about our pricing.

Pricing & Credits – ChainGPT AI NFT Generator

ChainGPT’s AI NFT Generator (API & SDK) uses a credit-based pricing model for all image generation and utilities. This means every request consumes ChainGPT Credits (CGPTc), where 1 credit = $0.01 USD. The pricing is consistent across the API, SDK, and web app – there is no markup for API usage. Developers only pay per use (pay-as-you-go), making costs transparent and easy to track.

Image Generation Pricing

ChainGPT’s NFT Generator offers three AI models for image creation, each suited to different needs:

• VeloGen – a fast, efficient model for quick drafts.

• NebulaForge XL – a high-fidelity model (XL) for premium, detailed outputs.

• VisionaryForge – a creative model for imaginative, high-quality visuals.

Despite their differences in speed and quality, all in-house models cost the same base amount in credits per image. You can customize each generation by adjusting the number of diffusion steps (which refines quality) and the output resolution, without changing the base credit cost. The table below summarizes pricing per image for each model, including optional enhancements:

Key Points:

• Base Generation Cost: Generating an image with any of the three models costs 1 credit per image by default. This covers any prompt and any supported base resolution, regardless of how many steps are used. (Using more steps yields higher quality but may take longer; it does not increase the credit cost.)

• Upscaling Cost: If you request HD/Enhanced output, the system will automatically apply the upscaler. This roughly doubles the cost – +1 credit for a single enhancement (so 2 credits total). All models support upscaling; for instance, VeloGen can upscale a 512px image to ~1920px. Upscaling twice (for even larger images) adds another credit (total 3 credits), though one pass is usually sufficient.

• Model Selection: Using VeloGen

Utilities Pricing

In addition to image generation, the ChainGPT NFT API provides several utility features to enhance your results or enforce content guidelines. Below is a breakdown of these tools, including which are free and which consume credits:

Model Comparison

All three models share the same base credit cost (1 credit per image). Select a model based on your project’s balance of speed and quality.

Credit Purchase Options

ChainGPT Credits (CGPTc) can be purchased directly through the ChainGPT dashboard. Credits never expire, and you can buy them on a one-time or recurring basis to suit your integration’s needs. Key points about purchasing credits:

• Credit Bundles: Credits are available in flexible amounts. For example, 1,000 credits cost $10 USD (since 1 credit = $0.01) – you can scale up as needed (e.g. 10,000 credits = $100) or purchase smaller/larger packs in the app. There is no minimum usage fee; you only pay for the credits you need, and you can top-up anytime. (For enterprise or high-volume needs, larger bulk packages are available.)

• Payment Methods: You can pay via credit/debit card or cryptocurrency. Supported crypto includes stablecoins like USDT/USDC and popular coins (e.g. ETH, BNB, TRX). Additionally, you may purchase credits using $CGPT (ChainGPT’s native token). All purchases are processed through the ChainGPT Crypto AI Hub interface for convenience.

• Discounts for $CGPT or Subscriptions:

All credit transactions and balances can be managed via your ChainGPT account dashboard. Credits are deducted in real-time as you make API/SDK calls, and you can monitor usage in the dashboard to plan when to top-up.

Best Practices & Tips

Follow these recommendations to efficiently use ChainGPT’s NFT Generator and maximize your credits:

1. Optimize Prompts with Enhancement: Before generating images repeatedly, use the Prompt Enhancement tool (1 credit). It helps create detailed, effective prompts on your first try, reducing unnecessary spending.

2. Prototype Quickly with VeloGen: Start initial tests and bulk generations with VeloGen (1 credit per image). It's fast and cost-effective, allowing quick iteration. Once satisfied, switch to NebulaForge XL or VisionaryForge for high-quality final outputs.

3. Use Image Upscaling Strategically: Only use upscaling (enhancement) when higher resolution or improved clarity is essential. For drafts or previews, skip enhancement to save credits. Apply 1× Upscale for improved quality or 2× Upscale for exceptional detail and resolution.

4. Adhere to Content Guidelines: Ensure prompts follow content guidelines to avoid blocked generations. Non-compliant prompts may still consume credits without producing results. Use clear, appropriate, family-friendly prompts.

5. Track Usage Regularly: Monitor your credit usage via the ChainGPT dashboard. Regular tracking helps you manage credits effectively and anticipate future needs. For consistent usage, set up automatic monthly top-ups to benefit from a 15% discount.

6. Validate with Samples Before Bulk Generation: When creating large NFT collections, always generate a small sample batch first. Validate prompt effectiveness and style consistency before committing credits to large-scale generation, ensuring your final batch meets your expectations.

ChainGPT AI NFT Generator SDK Documentation

The ChainGPT AI NFT Generator SDK provides a comprehensive suite of tools to create, manage, and prepare NFTs for minting. This includes enhancing prompts, generating images (synchronously and asynchronously), tracking generation progress, retrieving minting metadata, and querying supported blockchains and contract ABIs.

Table of Contents

1. Installation

2. Quick Start

3. SDK Initialization

4. NFT Service Overview

Installation

Install the ChainGPT SDK via pip:

Or add to your requirements.txt:

For development with environment variables:

Quick Start

Here's a minimal example to get you started:

SDK Initialization

Basic Initialization

Required Imports

NFT Service Overview

Access the NFT service through the client:

The NFT service provides seven main methods:

• enhance_prompt(): Improve prompts for better image generation

• generate_image(): Create images synchronously (fast preview)

• generate_nft_queue(): Queue asynchronous NFT generation (high quality)

• get_progress(): Track queued generation progress

NFT Service Methods

enhance_prompt()

Enhances or refines a text prompt for better image generation results.

Method Signature:

Parameters:

Request Model (EnhancePromptRequestModel):

Response Model (EnhancePromptResponseModel):

Example:

generate_image()

Generates an image synchronously based on the given prompt and parameters. Best for quick previews and testing.

Method Signature:

Parameters:

Request Model (GenerateImageRequestModel):

Response Model (GenerateImageResponseModel):

Image-to-Image Generation:

Example:

Image-to-Image Generation:

Using Traits:

generate_nft_queue()

Initiates an asynchronous NFT image generation job. Use this for high-quality images or when you don't need immediate results.

Method Signature:

Parameters:

Request Model (GenerateNFTQueueRequestModel):

Response Model (GenerateNFTQueueResponseModel):

Example:

get_progress()

Checks the status and progress of a queued NFT generation job.

Method Signature:

Parameters:

Response Model (NFTProgressResponseModel):

Example:

mint_nft_metadata()

Generates the metadata required for minting NFTs on a blockchain. Call this after NFT generation is complete.

Method Signature:

Parameters:

Request Model (MintNFTRequestModel):

Response Model (MintNFTResponseModel):

Example:

get_chains()

Retrieves the list of supported blockchain networks for NFT operations.

Method Signature:

Parameters:

Response Model (GetChainsResponseModel):

Chain Info Model (ChainInfoModel):

Example:

get_abi()

Provides the ABI (Application Binary Interface) of the ChainGPT NFT smart contract for direct blockchain interaction.

Method Signature:

Parameters: None

Response Model (ContractABIResponseModel):

Example:

Data Models & Types

TraitModel

Defines NFT traits/attributes for generation:

Error Models

All methods can raise the following exceptions:

Enums Reference

NFTImageModel

Available AI models for image generation:

ImageEnhanceOption

Image enhancement levels:

Error Handling

Basic Error Handling

Specific Error Scenarios

Complete Example

Here's a comprehensive example showing the full NFT creation workflow:

Best Practices

1. Resource Management

Always close the client when done:

2. Error Handling

Handle specific errors appropriately:

3. Progress Tracking

Use reasonable polling intervals:

4. Model Selection

Choose the right model for your use case:

5. Prompt Engineering

Create effective prompts:

New Features

Image-to-Image Generation

The NFT service now supports image-to-image generation, allowing you to create variations based on reference images:

Character Preservation

When using image-to-image generation, you can preserve character features from the reference image:

Enhanced Traits System

The traits system has been enhanced with better support for NFT collections:

Updated Chain Support

The chain information now includes more detailed network information:

Improved Response Structures

All API responses now follow a consistent structure with proper error handling:

This ensures better error handling and consistent data access patterns across all NFT service methods.

ChainGPT AI NFT Generator SDK Reference

Introduction

The ChainGPT AI NFT Generator SDK provides a JavaScript/TypeScript interface for generating AI-driven images and minting them as NFTs. It wraps the ChainGPT AI NFT Generator REST API, allowing developers to easily integrate image generation and NFT creation into their applications without dealing with raw HTTP requests or file handling. This reference guide covers the SDK's installation, configuration, and major functions, focusing on how to use the SDK in Node.js or web environments to create and mint AI-generated images.

Key capabilities:

• Generate AI art images from text prompts using ChainGPT’s proprietary models.

• Optionally enhance (upscale) images for higher resolution outputs.

• Create NFTs by generating an image and preparing it for minting in one flow.

• Mint the generated image as an NFT on various blockchain networks with a single call.

Note: This guide is for the SDK usage. If you prefer to call the REST API directly, refer to the API Reference. For a step-by-step tutorial on using the NFT Generator (with examples), see the QuickStart Guide. Ensure you have an API key from the ChainGPT platform and sufficient credits (or an appropriate subscription plan) before using the SDK (the SDK will throw an error if your API key is invalid or you run out of credits).

Installation

Install the SDK Package: The ChainGPT NFT Generator SDK is available as an npm package @chaingpt/nft. Add it to your project using npm or Yarn:

This will install the SDK and its TypeScript type declarations.

Import and initialize the SDK: The SDK exports an Nft class. Import this class and instantiate it with your API key (obtained from the ChainGPT developer dashboard):

Only the apiKey is required to configure the SDK. The SDK uses this key to authenticate your requests to ChainGPT’s API. By default, it will use ChainGPT’s hosted endpoints—no additional setup is needed beyond providing a valid API key.

Note: Keep your API key secure (do not hard-code it in client-side code or expose it publicly). Also ensure you have sufficient API credits or an active plan to perform NFT generations. If your key is invalid or you exceed your quota, the SDK will throw an Errors.NftError (see Error Handling below).

SDK Usage

Below are the primary methods provided by the Nft SDK instance. Each method is documented with its purpose, expected parameters, return values, and example usage.

generateImage(options)

Description: Generates an image from a text prompt using one of ChainGPT’s AI models, returning the image data. This function does not mint an NFT; it only performs image generation. Use generateImage when you want to create an image (for example, to let a user preview it) without immediately putting it on-chain. To generate an image and directly prepare it for minting, use generateNft() instead.

Parameters: (passed as properties of the options object)

• prompt (string, required): The text prompt describing the desired image. This can be any creative description of the image you want (e.g. "A futuristic city skyline at sunset, neon pink and orange hues").

• model (string, required): The identifier of the AI model to use for generation. Supported models include velogen, nebula_forge_xl, VisionaryForge. Each model has a different style or aesthetic (e.g. photorealistic, anime, 3D render, etc.). ChainGPT’s proprietary models are

Note on image size: Supported width × height combinations (aspect ratios) depend on the model (and whether enhancement is used). For example, Velogen supports base resolutions like 512×512 (square), 768×512 (landscape), 512×768 (portrait). With 2× enhancement, it can produce up to ~1920×1920 (square) and corresponding larger rectangles. Nebula Forge XL and VisionaryForge have their own supported dimensions (see Supported Models & Settings below for detailed resolution options). If you request a size that the model doesn’t support, the API may return an error or adjust to the nearest valid size. If height/width are not specified, the SDK will default to the model’s base default (usually a square format such as 512×512 or 1024×1024 depending on the model).

Returns: A Promise that resolves to an object containing the generated image data. On success, you can expect the image bytes (binary data) to be available (typically under a field like data or similar). The image is in JPEG format by default. You can take the returned binary data and save it to a file, send it to a client, or further process it as needed.

Example – Generate an image and save to a file (with explanations):

Example –Generate an image to image using Velogen

In this example, we used the velogen model to generate a 1024×1024 image from the given prompt, with a single upscaling enhancement. The resulting image bytes are written to generated-image.jpg. After running this code, that file will contain the AI-generated artwork. You can adjust the prompt, model, and other parameters as needed

Example – Character Reference NFT Image Generation

Multiple NFT Images Generation

This SDK accepts multiple prompts, generates multiple images, and saves them to a folder according to the specified parameters

Synchronous NFT Generation

generateNft(options)

Description: Generates an image and prepares NFT metadata from a text prompt, intended for minting. This call handles the AI image creation similarly to generateImage(), but also registers the result for minting (on ChainGPT’s backend) and returns metadata needed to proceed with minting. Typically, after generateNft completes, you would call mintNft() to actually mint the NFT on-chain. This method is synchronous in the sense that it waits for the image generation to finish before returning, so it can take some time (usually 30–60 seconds for the image to be generated). Under the hood, this corresponds to an API call that generates the image and prepares the NFT in one step.

Parameters: (passed in an options object; includes all generateImage parameters plus NFT-specific fields)

• All image generation parameters from generateImage(): You can include prompt, model, enhance, steps, width, height with the same meanings as described above. These control the image generation part of this call.

• walletAddress

(There are no parameters for NFT name/description in this step – those are provided later to the mintNft() call.)

Returns: A Promise that resolves to an object containing the generated NFT data. On success, the result will include:

• The image data (similar to what generateImage returns, i.e. the binary image bytes).

• A collectionId (string or UUID) that uniquely identifies this generation job and the associated metadata on ChainGPT’s backend.

The collectionId is important: it references the saved AI-generated image and metadata. You will use it to either check the generation status (if queued) or to mint the NFT. In the case of generateNft() (synchronous), the promise only resolves after the image is fully generated, so at that point the image is ready and collectionId can be used directly for minting.

Note: After generateNft() completes, the NFT is not yet on the blockchain. It’s essentially a prepared record (image + metadata) awaiting the minting step. You must call mintNft() with the returned collectionId to actually mint the NFT on-chain. This two-step process (generate then mint) allows you to, for example, confirm with a user or display the image before incurring blockchain costs.

Example – Generate an NFT then mint it (with explanations):

In this example, we first call generateNft() with a prompt and parameters including the wallet address and chain ID where we want to mint. When this completes, we get a collectionId (printed to console) which references the generated image and metadata. We then call mintNft() with that collectionId and provide an NFT name, description, and symbol. The SDK then handles the blockchain transaction to mint the NFT to the specified address on BSC Testnet (chainId 97). The mintResult would contain information about the minting operation (such as a transaction hash or token ID, depending on the implementation).

Example – Production usage (generate then mint, minimal code):

The above snippet omits comments for brevity. It generates an NFT on BSC (chain 56) for the given wallet address, then immediately mints it with a name, description, and symbol. In a real application, you should include error handling around these calls (e.g., try/catch) and perhaps update your UI to inform the user of progress between generation and minting.

generateNftWithQueue(options) – Asynchronous/Queued Generation

Description: Initiates an NFT generation task asynchronously, without waiting for the image to be fully generated. This function returns quickly with a collectionId that represents the queued generation job on ChainGPT’s servers. The actual image creation then happens in the background. You can use the returned collectionId to poll the job’s status via getNftProgress() and later call mintNft() to mint the NFT once the image is ready. This queued approach is useful for handling multiple generations in parallel or offloading longer generation times without blocking your application flow.

Parameters: Same as generateNft(options) above. You must provide all required fields (prompt, model, walletAddress, chainId) and any optional generation settings (enhance, steps, height, width) as needed.

Returns: A Promise that resolves to an object containing at least a collectionId for the queued generation request. The image data will not be available immediately in the response, since generation is still in progress. The collectionId is the key identifier you'll use to check progress and eventually mint the NFT. Essentially, if this call succeeds, it means the generation job was accepted and is now processing on the server.

Example – Queue an NFT generation and check progress (with explanations):

In this example, we queue an NFT generation using generateNftWithQueue(). The call returns immediately with a collectionId (stored in jobId). We then enter a loop to poll the job’s status using getNftProgress(), every 5 seconds, logging the progress percentage. Once the status becomes "completed" (which implies 100% progress), we proceed to call mintNft() with the same collectionId to mint the NFT on-chain. In a real application, you might use a longer delay between polls or integrate a webhook/callback if available, rather than busy polling. You can also queue multiple jobs in parallel and poll each one, which makes this approach suitable for generating large collections of NFTs asynchronously.

Example – Production usage (queue generation, minimal):

Here we simply queue the generation and log the job ID. The subsequent steps (polling progress and minting) would be similar to the detailed example above. This pattern allows your code to continue doing other work or handling other requests while images are being generated in the background.

getNftProgress(options)

Description: Checks the status of an NFT generation job that was started with generateNftWithQueue() (or even a generateNft() call if you want to poll its progress, though generateNft() usually waits internally). It returns information about the generation progress, such as a percentage complete or a status indicator.

Parameters:

• collectionId (string, required): The unique identifier of the NFT generation job to query. This is the collectionId returned by generateNft or generateNftWithQueue. Without a valid collectionId, the API cannot identify which job’s status to retrieve.

Returns: A Promise that resolves to an object containing progress information for the specified job. The exact structure of the data may include fields like progress (number) and status (string). For example, a successful response might be { progress: 100, status: "completed", ... } when the generation is finished. Before completion, you might see a lower progress value (e.g. 0 to 99) and a status like "processing" or "queued". If an invalid collectionId is provided, the SDK will throw an error or you might get a response indicating the job wasn’t found.

Typically, you will call this method repeatedly (polling) until the status is "completed" or progress reaches 100, then proceed to mint the NFT. The frequency of polling can be adjusted based on how long generations typically take (e.g., polling every few seconds).

Example – Basic usage:

Example – Production snippet (single progress check):

In practice, you would integrate this into a loop or schedule as shown in the queued generation example. Use getNftProgress() to inform users about the generation status (e.g., a loading bar) or to trigger the next step of your workflow when the image is ready.

mintNft(options)

Description: Mints an NFT on the specified blockchain, using a previously generated image/metadata. This is the final step in the NFT creation process, taking the output of generateNft (identified by a collectionId) and writing the NFT to the blockchain. The method also lets you set the NFT’s name, description, and symbol (metadata) if they weren't already set. Under the hood, this will interact with ChainGPT’s NFT minting smart contract to either create a new NFT in an existing collection or deploy a new collection, then mint the token to the provided wallet address.

Parameters:

• collectionId (string, required): The ID of the generated NFT content to mint. This is obtained from a prior generateNft or generateNftWithQueue call. It tells the system which image/metadata to use for minting.

• name (string, required): The name for the NFT. This could be the title of the artwork or any descriptive name. This will appear as the token’s name in metadata.

Returns: A Promise that resolves to an object containing the result of the mint operation. On success, this will typically include details such as:

• Confirmation that the NFT was minted (e.g., a success status or the minted token’s ID/URL).

• Transaction details, like a transaction hash, if the mint involved an on-chain transaction.

• Possibly the address of the new NFT collection contract (if one was deployed) or confirmation of the collection used.

The exact fields returned may vary, but the key outcome is that the image identified by collectionId is now minted as an NFT owned by walletAddress (which was provided during generation). The promise will only resolve once the minting is complete (which may involve waiting for a blockchain transaction).

After calling mintNft(), the NFT is live on the blockchain. You can then fetch it from the blockchain or via ChainGPT’s APIs, and it will have the metadata (name, description, etc.) that you provided.

Example – Mint an NFT directly (assuming image is already generated):

In this example, we directly call mintNft() using a known collectionId (from a prior generation step) and provide the desired metadata. If the operation succeeds, the console will log a success message. In a real scenario, you’d want to wrap this in a try/catch to handle errors (like network issues or insufficient permissions) and perhaps confirm the transaction result.

Example – Production snippet:

Typically, you will call mintNft() once per generated image to put it on-chain. Remember to catch errors from this call as it involves external blockchain interaction (see Error Handling below). For instance, if the user’s wallet is invalid or if there are network fees required that the system cannot cover, you would get an error.

Enhance Your Prompt

Update your prompt by setting the enhancement level to receive a response tailored to the enhanced prompt.

Generate Random Prompt (Surprise Me)

Run this snippet of code to receive a surprise prompt for generating an NFT.

Get Collections with Filters

This example demonstrates how to use the @chaingpt/nft SDK to retrieve NFT collections associated with a specific wallet address.

Parameters

Toggle NFT Visibility

toggle the visibility status (e.g., from public to private or vice versa) of an NFT collection using the @chaingpt/nft SDK.

Supported Models & Settings

(This section provides reference details on the supported AI models, image enhancements, and output formats available in the ChainGPT NFT Generator SDK.)

• Supported AI Models: You can choose from several AI models via the model parameter in generateImage/generateNft:

  • velogen – ChainGPT’s VeloGen model, suitable for realistic or general-purpose image generation.

Error Handling

The ChainGPT NFT SDK provides a structured error handling mechanism to help you catch and manage errors from any SDK call (image generation, minting, etc.).

When something goes wrong (such as a network issue, an invalid API request, or an error returned from the ChainGPT API), the SDK will throw an error of type Errors.NftError. This is a custom error class provided by the SDK. It includes a message describing the error, and it may include additional information such as an HTTP status code or an error payload from the API.

How to handle errors: Ensure you wrap your SDK calls in a try...catch block in your async function. In the catch, you can check if the caught error is an instance of Errors.NftError to distinguish it from other types of exceptions.

Example – Error handling pattern:

In the above snippet, if nft.generateNft() fails (for example, due to an invalid API key, a 400 Bad Request from the API, or a network timeout), the catch block will execute. The error’s message (error.message) usually provides a human-readable description of what went wrong (e.g. "Unauthorized" for invalid API key, or a specific validation message). By checking instanceof Errors.NftError, we ensure we’re handling errors thrown by the ChainGPT SDK. Any other error would fall to the else block (which could be a coding mistake or something unrelated).

Common error scenarios to handle:

• Authentication failures: If your API key is missing, incorrect, or expired, the SDK will throw an NftError (often indicating a 401 or 403 HTTP error under the hood). You should catch this and prompt for a correct key or notify about invalid credentials.

• Invalid parameters: If you pass values that the API cannot process (e.g., an unsupported image resolution, or missing a required field like walletAddress), the API will respond with a 400 error and the SDK will throw an NftError with details. Check the message to adjust your request.

By consistently catching Errors.NftError, you can gracefully handle all these cases. The SDK abstracts away the need to manually parse HTTP responses; any non-2xx HTTP response or other failure will result in a thrown NftError that you can catch in one place. This makes it easier to implement robust error-handling logic (such as retries, user notifications, or logging) around SDK calls.

Additional Resources

• ChainGPT Developer Dashboard: To obtain your API key or manage your subscription/credits, visit the ChainGPT Developer Dashboard on the ChainGPT website. This is where you can monitor your usage and top up credits if needed.

• Pricing & Credits: For details on how the credit system works and the cost of generating images or NFTs, refer to the Pricing & Membership Plans page on the ChainGPT documentation site. (Pricing is subject to change and depends on the model and enhancements used, so it’s maintained separately from this SDK reference.)

• NPM Package Documentation: You can find the SDK’s package page on , which may include additional usage examples and the latest version information.

This SDK reference is meant to be a comprehensive guide for developers. For any further help, check out the QuickStart guide for step-by-step examples or contact the ChainGPT support team. Happy building with the ChainGPT AI NFT Generator SDK!

ChainGPT AI NFT Generator API Reference

Introduction

This reference describes the RESTful API endpoints for the ChainGPT AI NFT Generator. It covers endpoints for generating AI-based images and NFTs, along with supporting endpoints for prompt enhancement, chain information, and contract ABI. Each endpoint is documented with its method, path, required headers, parameters, and example requests/responses. Use this guide to integrate AI image generation and NFT minting into your applications.