3D Models Overview

Create 3D objects, generate meshes, and manipulate three-dimensional content with cutting-edge AI 3D generation models.

Available Models

Text-to-3D Models

DreamGaussian: Fast 3D object generation from text descriptions
Magic3D: High-quality text-to-3D with detailed geometry
ProlificDreamer: Advanced 3D generation with realistic textures

Image-to-3D Models

TripoSR: Single image to 3D mesh conversion
Wonder3D: Multi-view consistent 3D reconstruction
Zero-1-to-3: Novel view synthesis and 3D generation

Point Cloud Models

Point-E: 3D point cloud generation from text
Shap-E: Text and image to 3D shape generation
Point Cloud Diffusion: High-resolution point cloud synthesis

3D Editing Models

InstructNeRF2NeRF: Edit 3D scenes with text instructions
DreamEditor: Semantic editing of 3D objects
Vox-E: Voxel-based 3D shape editing

Model Capabilities

Text-to-3D

Generate 3D objects from text descriptions

Image-to-3D

Convert 2D images into 3D models

3D Editing

Modify and edit existing 3D content

Mesh Generation

Create detailed 3D meshes and geometry

3D Generation API

Generate 3D models from text descriptions:

POST /v1/3d/generations

Text-to-3D Example

curl -X POST "https://api.anyapi.ai/v1/3d/generations" \
  -H "Authorization: Bearer your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "dreamgaussian",
    "prompt": "A vintage wooden chair with carved details",
    "output_format": "obj",
    "quality": "high",
    "texture_resolution": 1024
  }'

Image-to-3D Example

import requests

# Upload reference image
files = {'image': open('chair_reference.jpg', 'rb')}

data = {
    'model': 'triposr',
    'output_format': 'glb',
    'quality': 'high',
    'texture_quality': 'medium'
}

response = requests.post(
    "https://api.anyapi.ai/v1/3d/image-to-3d",
    headers={"Authorization": "Bearer your_api_key"},
    files=files,
    data=data
)

Response Format

{
  "id": "3d_abc123",
  "object": "3d_model",
  "created": 1589478378,
  "model": "dreamgaussian",
  "status": "processing",
  "urls": {
    "obj": null,
    "mtl": null,
    "textures": null,
    "preview": null
  },
  "metadata": {
    "vertices": null,
    "faces": null,
    "texture_resolution": 1024,
    "output_format": "obj"
  }
}

3D Status API

Check the status of 3D model generation:

GET /v1/3d/{model_id}

import requests
import time

def wait_for_3d_model(model_id):
    """Wait for 3D model generation to complete"""
    while True:
        response = requests.get(
            f"https://api.anyapi.ai/v1/3d/{model_id}",
            headers={"Authorization": "Bearer your_api_key"}
        )
        
        model_data = response.json()
        
        if model_data['status'] == 'completed':
            return model_data['urls']
        elif model_data['status'] == 'failed':
            raise Exception(f"3D generation failed: {model_data.get('error')}")
        
        time.sleep(30)  # Wait 30 seconds before checking again

# Usage
model_urls = wait_for_3d_model("3d_abc123")
print(f"OBJ file: {model_urls['obj']}")
print(f"Texture: {model_urls['textures']}")

Point Cloud API

Generate 3D point clouds:

POST /v1/3d/point-clouds

import requests

response = requests.post(
    "https://api.anyapi.ai/v1/3d/point-clouds",
    headers={
        "Authorization": "Bearer your_api_key",
        "Content-Type": "application/json"
    },
    json={
        "model": "point-e",
        "prompt": "A modern sports car with sleek design",
        "num_points": 2048,
        "output_format": "ply",
        "color": True
    }
)

3D Editing API

Edit existing 3D models with text instructions:

POST /v1/3d/edit

import requests

# Upload 3D model file
files = {'model': open('original_model.obj', 'rb')}

data = {
    'instruction': 'Change the color to bright red and add metallic finish',
    'edit_model': 'dreameditor',
    'preserve_geometry': True
}

response = requests.post(
    "https://api.anyapi.ai/v1/3d/edit",
    headers={"Authorization": "Bearer your_api_key"},
    files=files,
    data=data
)

Model Comparison

Model	Type	Quality	Speed	Best For
DreamGaussian	Text-to-3D	High	Fast	General objects
Magic3D	Text-to-3D	Very High	Slow	Detailed models
TripoSR	Image-to-3D	High	Medium	Single view reconstruction
Point-E	Point Cloud	Medium	Fast	Prototyping

Output Formats

Mesh Formats

OBJ: Universal format with MTL materials
GLB/GLTF: Web-optimized format
PLY: Point cloud and mesh data
STL: For 3D printing
FBX: Animation and complex scenes

Point Cloud Formats

PLY: Most common point cloud format
PCD: Point Cloud Data format
XYZ: Simple coordinate format
LAS: Large-scale point clouds

Texture Formats

PNG: High-quality textures with transparency
JPG: Compressed textures
EXR: HDR textures
TIFF: Uncompressed high-quality

Advanced Features

Multi-View Generation

Generate consistent views of 3D objects:

def generate_multiview_3d(prompt, num_views=4):
    """Generate 3D model with multiple consistent views"""
    response = requests.post(
        "https://api.anyapi.ai/v1/3d/multiview",
        headers={
            "Authorization": "Bearer your_api_key",
            "Content-Type": "application/json"
        },
        json={
            "model": "wonder3d",
            "prompt": prompt,
            "num_views": num_views,
            "view_angles": [0, 90, 180, 270],  # degrees
            "output_format": "glb",
            "texture_resolution": 2048
        }
    )
    
    return response.json()

# Usage
multiview_model = generate_multiview_3d("A detailed dragon sculpture")

Texture Enhancement

Enhance 3D model textures:

def enhance_3d_textures(model_id, enhancement_type="realistic"):
    """Enhance textures of existing 3D model"""
    response = requests.post(
        f"https://api.anyapi.ai/v1/3d/{model_id}/enhance-textures",
        headers={
            "Authorization": "Bearer your_api_key",
            "Content-Type": "application/json"
        },
        json={
            "enhancement_type": enhancement_type,  # "realistic", "stylized", "cartoon"
            "texture_resolution": 2048,
            "apply_lighting": True,
            "material_type": "pbr"  # physically based rendering
        }
    )
    
    return response.json()

Animation Generation

Create simple animations for 3D models:

def generate_3d_animation(model_id, animation_type="rotation"):
    """Generate animation for 3D model"""
    response = requests.post(
        f"https://api.anyapi.ai/v1/3d/{model_id}/animate",
        headers={
            "Authorization": "Bearer your_api_key",
            "Content-Type": "application/json"
        },
        json={
            "animation_type": animation_type,  # "rotation", "float", "bounce"
            "duration": 3.0,  # seconds
            "fps": 30,
            "loop": True,
            "output_format": "glb"
        }
    )
    
    return response.json()

Prompt Engineering for 3D

Best Practices

Be specific about shape: “spherical”, “cylindrical”, “angular”
Describe materials: “wooden”, “metallic”, “plastic”, “glass”
Include style references: “modern”, “vintage”, “futuristic”, “minimalist”
Specify scale context: “furniture-sized”, “handheld object”, “architectural”
Mention key features: “with handles”, “textured surface”, “smooth finish”

Example Prompts

Furniture

“A modern minimalist coffee table with clean lines, made of light oak wood with a matte finish, rectangular shape with rounded corners, approximately 120cm long”

Decorative Object

“An ornate Victorian-style brass candlestick holder with intricate floral engravings, aged patina finish, approximately 25cm tall with a wide base”

Vehicle

“A sleek futuristic sports car with aerodynamic design, metallic silver paint, LED headlights, low profile with aggressive stance”

Architecture

“A small modern house with floor-to-ceiling windows, flat roof, white concrete walls, surrounded by a minimalist garden”

Technical Specifications

Processing Times

Text-to-3D: 10-30 minutes depending on quality
Image-to-3D: 5-15 minutes
Point clouds: 2-5 minutes
3D editing: 5-20 minutes

Quality Settings

Standard Quality

Vertices: 10,000-50,000
Texture resolution: 512x512
Processing time: 5-10 minutes

High Quality

Vertices: 50,000-200,000
Texture resolution: 1024x1024
Processing time: 15-30 minutes

Ultra Quality

Vertices: 200,000+
Texture resolution: 2048x2048
Processing time: 30-60 minutes

Pricing

3D models are priced based on quality and processing time:

Model Type	Standard	High	Ultra
Text-to-3D	$5.00	$12.00	$25.00
Image-to-3D	$3.00	$8.00	$18.00
Point Cloud	$1.00	$3.00	$6.00
3D Editing	$2.00	$5.00	$10.00

Additional costs:

High-resolution textures (2K+): +50%
Animation generation: +$3.00
Multi-view generation: +100%

Rate Limits

3D model generation limits by plan:

Plan	Generations/Day	Concurrent Jobs	Max Quality
Free	3	1	Standard
Pro	25	3	High
Enterprise	Custom	Custom	Ultra

Common Use Cases

Game Development

Asset creation, character models, environment objects

3D Printing

Prototypes, custom parts, decorative objects

Architecture & Design

Concept models, furniture design, spatial planning

E-commerce

Product visualization, interactive catalogs

Education

Teaching aids, scientific models, interactive learning

Marketing & Advertising

Product mockups, brand visualization, campaigns

Film & Animation

Asset creation, pre-visualization, concept art

Virtual/Augmented Reality

VR/AR content, immersive experiences

Integration Examples

Three.js Web Viewer

import * as THREE from 'three';
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';

class Model3DViewer {
  constructor(containerId) {
    this.container = document.getElementById(containerId);
    this.scene = new THREE.Scene();
    this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
    this.renderer = new THREE.WebGLRenderer();
    
    this.init();
  }
  
  init() {
    this.renderer.setSize(this.container.clientWidth, this.container.clientHeight);
    this.container.appendChild(this.renderer.domElement);
    
    // Add lighting
    const ambientLight = new THREE.AmbientLight(0x404040, 0.6);
    this.scene.add(ambientLight);
    
    const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
    directionalLight.position.set(1, 1, 1);
    this.scene.add(directionalLight);
    
    this.camera.position.z = 5;
  }
  
  async loadModel(modelUrl) {
    const loader = new GLTFLoader();
    
    try {
      const gltf = await new Promise((resolve, reject) => {
        loader.load(modelUrl, resolve, undefined, reject);
      });
      
      this.scene.add(gltf.scene);
      this.animate();
      
      return gltf;
    } catch (error) {
      console.error('Error loading 3D model:', error);
      throw error;
    }
  }
  
  animate() {
    requestAnimationFrame(() => this.animate());
    
    // Rotate the model
    this.scene.rotation.y += 0.005;
    
    this.renderer.render(this.scene, this.camera);
  }
}

// Usage
const viewer = new Model3DViewer('model-container');

// Generate and load model
async function generateAndView3DModel() {
  try {
    // Generate 3D model
    const response = await fetch('/api/generate-3d', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        prompt: 'A modern lamp with geometric design',
        format: 'glb'
      })
    });
    
    const result = await response.json();
    
    // Load the generated model
    await viewer.loadModel(result.model_url);
    
  } catch (error) {
    console.error('Failed to generate or load 3D model:', error);
  }
}

Unity Integration

using UnityEngine;
using System.Collections;
using UnityEngine.Networking;

public class AnyAPI3DLoader : MonoBehaviour
{
    private string apiKey = "your_api_key";
    private string baseUrl = "https://api.anyapi.ai/v1/3d";
    
    public async void Generate3DModel(string prompt)
    {
        string modelId = await RequestModelGeneration(prompt);
        if (!string.IsNullOrEmpty(modelId))
        {
            await WaitForModelCompletion(modelId);
            await LoadGeneratedModel(modelId);
        }
    }
    
    private async System.Threading.Tasks.Task<string> RequestModelGeneration(string prompt)
    {
        var requestData = new
        {
            model = "dreamgaussian",
            prompt = prompt,
            output_format = "glb",
            quality = "high"
        };
        
        string jsonData = JsonUtility.ToJson(requestData);
        
        using (UnityWebRequest request = UnityWebRequest.Post($"{baseUrl}/generations", jsonData, "application/json"))
        {
            request.SetRequestHeader("Authorization", $"Bearer {apiKey}");
            
            await request.SendWebRequest();
            
            if (request.result == UnityWebRequest.Result.Success)
            {
                var response = JsonUtility.FromJson<GenerationResponse>(request.downloadHandler.text);
                return response.id;
            }
            
            Debug.LogError($"3D generation request failed: {request.error}");
            return null;
        }
    }
    
    private async System.Threading.Tasks.Task WaitForModelCompletion(string modelId)
    {
        while (true)
        {
            using (UnityWebRequest request = UnityWebRequest.Get($"{baseUrl}/{modelId}"))
            {
                request.SetRequestHeader("Authorization", $"Bearer {apiKey}");
                
                await request.SendWebRequest();
                
                if (request.result == UnityWebRequest.Result.Success)
                {
                    var status = JsonUtility.FromJson<ModelStatus>(request.downloadHandler.text);
                    
                    if (status.status == "completed")
                        break;
                    else if (status.status == "failed")
                        throw new System.Exception("Model generation failed");
                }
            }
            
            await System.Threading.Tasks.Task.Delay(30000); // Wait 30 seconds
        }
    }
    
    private async System.Threading.Tasks.Task LoadGeneratedModel(string modelId)
    {
        // Implementation depends on your GLB loading solution
        // You might use packages like GLTFUtility or Siccity.GLTFUtility
    }
}

[System.Serializable]
public class GenerationResponse
{
    public string id;
    public string status;
}

[System.Serializable]
public class ModelStatus
{
    public string status;
    public ModelUrls urls;
}

[System.Serializable]
public class ModelUrls
{
    public string glb;
    public string preview;
}

Getting Started

Quick Start

Generate your first 3D model

Use Cases

See practical examples

SDKs

Use our libraries

API Reference

Explore all endpoints

Documentation Index

​3D Models Overview

​Available Models

​Text-to-3D Models

​Image-to-3D Models

​Point Cloud Models

​3D Editing Models

​Model Capabilities

Text-to-3D

Image-to-3D

3D Editing

Mesh Generation

​3D Generation API

​Text-to-3D Example

​Image-to-3D Example

​Response Format

​3D Status API

​Point Cloud API

​3D Editing API

​Model Comparison

​Output Formats

​Mesh Formats

​Point Cloud Formats

​Texture Formats

​Advanced Features

​Multi-View Generation

​Texture Enhancement

​Animation Generation

​Prompt Engineering for 3D

​Best Practices

​Example Prompts

​Technical Specifications

​Processing Times

​Quality Settings

​Standard Quality

​High Quality

​Ultra Quality

​Pricing

​Rate Limits

​Common Use Cases