Vision API

Complete API documentation for integrating vision.meme into your applications. Build custom meme token launchpads and manage Solana Token-2022 tokens with on-chain metadata programmatically.

---

Base URL

https://api.vision.meme

All API requests should be made to this base URL. Use HTTPS for all requests.

---

API Architecture

The vision.meme API follows RESTful principles:

• Resource-based URLs - Endpoints represent resources (tokens, distributions, etc.)

• HTTP methods - Standard methods (GET, POST, PATCH, DELETE)

• JSON format - All request and response bodies use JSON

• Stateless - Each request contains all necessary information

• Predictable structure - Consistent response formats

---

Request Format

Headers

All requests should include these headers:

http

Content-Type: application/json

For authenticated endpoints, also include:

http

Authorization: Bearer <your_jwt_token>

Example Request

bash

curl https://api.vision.meme/tokens/YourMintAddress \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

---

Response Format

Success Responses

All successful responses return JSON with appropriate HTTP status codes.

200 OK - Successful GET, PATCH, or DELETE request:

json

{
  "token": {
    "id": "uuid",
    "mintAddress": "TokenMintAddress...",
    "name": "Vision Meme",
    "symbol": "VISION"
  }
}

201 Created - Successful POST request creating a resource:

json

{
  "success": true,
  "token": {
    "id": "uuid",
    "mintAddress": "TokenMintAddress..."
  }
}

Error Responses

All errors return JSON with appropriate HTTP status codes and error details.

Standard Error Format:

json

{
  "error": "Error message describing what went wrong",
  "details": []
}

Validation Error Format:

json

{
  "error": "Validation error",
  "details": [
    {
      "path": ["fieldName"],
      "message": "Specific validation error message"
    }
  ]
}

---

HTTP Status Codes

Code	Name	Meaning
200	OK	Request successful
201	Created	Resource created successfully
400	Bad Request	Invalid request parameters or validation error
401	Unauthorized	Missing or invalid authentication token
403	Forbidden	Authenticated but not authorized for this resource
404	Not Found	Resource does not exist
429	Too Many Requests	Rate limit exceeded
500	Internal Server Error	Server error occurred

---

Data Types

Common Field Types

String

json

"name": "Vision Meme"

Number

json

"transferFeePercent": 5

Boolean

json

"distributionEnabled": true

Array

json

"tokens": [...]

Object

json

"token": {
  "id": "uuid",
  "name": "Vision Meme"
}

Null

json

"telegram": null

Solana-Specific Types

Mint Address - 32-44 character base58 string

json

"mintAddress": "DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK"

Wallet Address - 32-44 character base58 string

json

"walletAddress": "DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK"

Transaction Signature - Base58 encoded string

json

"signature": "5VhQ7FqjkqQJ..."

Base64 Transaction - Base64 encoded transaction

json

"transaction": "AQAAAAAAAAAAAAAA..."

Amount Representation

All token amounts are represented as strings in smallest units (lamports for SOL, base units for tokens):

json

{
  "supply": "1000000000000000",    // 1B tokens with 6 decimals
  "solAmount": "20000000000",      // 20 SOL (9 decimals)
  "tokenAmount": "700000000000"    // 700M tokens (6 decimals)
}

Conversion Examples:

javascript

// Tokens (6 decimals)
1,000,000 tokens = "1000000000000" (string)

// SOL (9 decimals)
20 SOL = "20000000000" (string)

// Converting to human-readable:
const tokens = parseInt("1000000000000") / Math.pow(10, 6); // 1000000
const sol = parseInt("20000000000") / Math.pow(10, 9);      // 20

---

Pagination

List endpoints support pagination using query parameters:

Parameters:

• page (number, default: 1) - Page number

• limit (number, default: 20, max: 100) - Items per page

Request:

bash

GET https://api.vision.meme/tokens?page=2&limit=50

Response:

json

{
  "tokens": [...],
  "pagination": {
    "total": 150,
    "page": 2,
    "limit": 50,
    "totalPages": 3
  }
}

---

Timestamps

All timestamps are in ISO 8601 format with UTC timezone:

json

{
  "createdAt": "2024-01-01T12:00:00Z",
  "updatedAt": "2024-01-01T12:30:00Z",
  "expiresAt": "2024-01-01T12:05:00Z"
}

Parsing in JavaScript:

javascript

const date = new Date("2024-01-01T12:00:00Z");
console.log(date.toLocaleString()); // "1/1/2024, 12:00:00 PM"

---

Request IDs

Each API request receives a unique request ID for tracking and debugging:

Response Headers:

http

X-Request-Id: req_abc123def456

Include this ID when contacting support about specific requests.

---

Idempotency

Some endpoints support idempotency to safely retry requests:

Idempotent Methods:

• GET - Always safe to retry

• PUT - Same result on multiple calls

• DELETE - Same result on multiple calls

Non-Idempotent Methods:

• POST - May create duplicate resources if retried

Best Practice: For POST requests, store the response on first success to avoid duplicates when retrying.

---

API Versioning

The vision.meme API does not currently use URL versioning. Breaking changes will be communicated in advance through:

• Email notifications

• Documentation updates

• Changelog entries

• Deprecation warnings in responses

Current Version: 1.0

Backward Compatibility:

• New fields added to responses (non-breaking)

• New optional request parameters (non-breaking)

• New endpoints (non-breaking)

Breaking Changes (future):

• Removal of fields

• Changed field types

• Required new parameters

• Changed response structure

---

Environments

Production

Base URL: https://api.vision.meme Blockchain: Solana Mainnet Use for: Live token creation and real transactions

Development

Recommendation: Use Solana Devnet for testing

Steps:

1. Test wallet-based authentication

2. Create test tokens on devnet

3. Verify integration logic

4. Move to production when ready

Note: The API always interacts with Solana Mainnet. Use devnet for blockchain testing outside the API.

---

Common Patterns

Creating a Token

1. Authenticate
   POST /auth/challenge
   POST /auth/verify
   
2. Generate distribution wallet
   POST /tokens/generate-distribution-wallet
   
3. Upload image
   POST /tokens/upload-image
   
4. Create unsigned transaction
   POST /tokens/create-unsigned
   
5. Sign transaction (client-side)
   
6. Submit signed transaction
   POST /tokens/submit

Updating Distribution Settings

1. Authenticate (if needed)
   
2. Get current settings
   GET /distribution/:tokenId/settings
   
3. Update settings
   PATCH /distribution/:tokenId/settings

Adding Liquidity

1. Authenticate
   
2. Create unsigned pool transaction
   POST /dex/raydium/cpmm/create-unsigned
   
3. Sign transaction (client-side)
   
4. Submit to Solana (client-side)

---

Best Practices

Error Handling

Always wrap API calls in try-catch blocks:

javascript

try {
  const response = await fetch('https://api.vision.meme/tokens/me', {
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    }
  });
  
  if (!response.ok) {
    const error = await response.json();
    console.error('API Error:', error);
    // Handle error appropriately
  }
  
  const data = await response.json();
  // Process data
} catch (error) {
  console.error('Network Error:', error);
  // Handle network error
}

Rate Limit Handling

Check rate limit headers and implement backoff:

javascript

const response = await fetch(url, options);

const remaining = parseInt(response.headers.get('X-RateLimit-Remaining'));
const reset = parseInt(response.headers.get('X-RateLimit-Reset'));

if (response.status === 429) {
  const retryAfter = parseInt(response.headers.get('Retry-After'));
  await sleep(retryAfter * 1000);
  // Retry request
}

Token Refresh

JWT tokens expire in 7 days. Check expiration and refresh:

javascript

function isTokenExpired(token) {
  const payload = JSON.parse(atob(token.split('.')[1]));
  return payload.exp * 1000 < Date.now();
}

async function getValidToken() {
  if (!token || isTokenExpired(token)) {
    token = await authenticate();
  }
  return token;
}

Request Timeouts

Set appropriate timeouts for different operations:

javascript

// Short timeout for quick operations
const quickTimeout = 5000; // 5 seconds

// Long timeout for blockchain operations
const blockchainTimeout = 30000; // 30 seconds

const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), timeout);

try {
  const response = await fetch(url, {
    signal: controller.signal,
    ...options
  });
} finally {
  clearTimeout(timeoutId);
}

---

Rate Limits

See Rate Limits for detailed information on limits by endpoint category.

---

Authentication

See Authentication for details on the wallet-based JWT authentication flow.

---

Error Handling

See Error Handling for comprehensive error codes and handling strategies.

---

Next Steps

• Authentication Guide - Learn how to authenticate

• Token Endpoints - Create and manage tokens

• Code Examples - Working examples in multiple languages

---

Need Help?

• 📚 Full API Reference

• 💬 Discord Community

• 📱 Telegram Support

• 📧 Email Support

---

© 2025 Vision.meme. All rights reserved.