Build With ODview

Add AI-powered PBR material generation to your application. RESTful API, Python/JavaScript SDKs, webhooks, and batch processing. Production-ready with 99.9% uptime SLA. Get started in 5 minutes.

5-Minute Quickstart

Copy-paste code example

3 Integration Methods

REST API, SDKs, webhooks

Production Ready

99.9% SLA guaranteed

Generous Free Tier

10k requests/month free

 1import odview
 2
 3client = odview.Client(api_key="sk_test_...")
 4
 5response = client.materials.generate(
 6    prompt="Worn leather with scuffs",
 7    style="photorealistic"
 8)
 9
10print(response.albedo_url)

Get Started in 5 Minutes

Copy one of these examples and you'll be generating materials in minutes.

1Install the SDK

pip install odview

2Initialize Client

import odview

client = odview.Client(api_key="sk_live_...")

3Generate Materials

response = client.materials.generate(
    prompt="Worn wooden table, weathered oak",
    format="gltf"
)

print(response.albedo_url)

4Download & Use

import requests
from pathlib import Path

for map_type in ['albedo', 'normal', 'roughness']:
    url = getattr(response, f'{map_type}_url')
    r = requests.get(url)
    Path(f'material_{map_type}.png').write_bytes(r.content)

Choose Your Integration Path

Pick the approach that fits your architecture. Mix and match for maximum flexibility.

REST API

Direct HTTP calls

Best for:

Simple integrations
One-off requests
Any language/platform
Microservices

100+ endpoints, Full REST semantics, Sub-3s P50

Language SDKs

Type-safe, battle-tested

PythonJavaScriptGoRubyRust

Best for:

Native language integration
Type safety
Developer experience
Production applications

Request/response objects, Error handling, Async/await

Webhooks & Events

Event-driven architecture

• Material generation started

• Material generation completed

• Webhook delivery failed

Best for:

Async processing
Background jobs
Multiple integrations
Scale to 1000s of requests

Sub-100ms delivery, Guaranteed at-least-once

API Capabilities

Complete REST API with comprehensive features for every use case.

Generate Single Material

POST /v1/materials/generate

Instantly generate high-quality PBR materials from text descriptions

Parameters:

• prompt (string, required)
• format (enum: gltf, glb, jpg)
• quality (enum: standard, high, ultra)
• style (enum: photorealistic, stylized, hand-painted)

Response Fields:

idstatusalbedo_urlnormal_urlroughness_url

~2.8s average, 99.97% success rate

Batch Processing

POST /v1/batches

Generate hundreds of materials asynchronously.

Parameters:

• materials (array of objects, up to 1000)
• callback_url (string)
• priority (enum: low, normal, high)

Process 1000s overnight, 10x cost savingsWebhook notification, Automatic retry, Progress tracking

Real-time Webhooks

Event stream

Subscribe to material generation events.

Event Types:

material.createdmaterial.completedmaterial.failedbatch.completed

<100ms delivery, Guaranteed at-least-onceHMAC signature verification included

Material Management

CRUD operations

Store, organize, retrieve, and delete materials.

Endpoints:

GET /v1/materials/{id}
POST /v1/materials/{id}/library
GET /v1/library
DELETE /v1/materials/{id}

Unlimited storage, Full-text search, Tagging & categories

Real-World Examples

Copy and modify these examples for your specific use case.

E-commerce Product Customizer

Generate custom materials for products

15 minutes

PythonJavaScript

Highlights:

Error handling
Database integration pattern
Return both IDs and URLs
Production-ready patterns

Product page → User inputs → API request → Generate → Download → 3D preview

Game Engine Material Pipeline

Procedurally generate game assets

30 minutes

PythonUnity, Unreal Engine compatible

Highlights:

Batch processing with 1000s of materials
Webhook integration
Game-engine ready outputs
Async processing patterns

Interior Design Tool - Real-Time Preview

Stream updates to 3D viewer

45 minutes

JavaScriptNode.js + Socket.io

Highlights:

Real-time WebSocket updates
Multi-user collaboration
Error handling
State management

Mobile AR Application

Generate materials for iOS/Android

60 minutes

JavaScriptReact Native

Highlights:

Platform-specific exports
Local caching for offline
AR view integration
iOS + Android support

Error Handling & Best Practices

Learn how to build reliable applications with ODview.

HTTP Status Codes

200OK

Process result normally

400Bad Request

Check prompt, format, etc.

401Unauthorized

Verify API key

429Too Many Requests

Implement exponential backoff

500Server Error

Retry after 60-120 seconds

Retry Logic with Exponential Backoff

import time
import random

def generate_with_retry(prompt, max_retries=5):
    for attempt in range(max_retries):
        try:
            response = client.materials.generate(prompt=prompt)
            return response
        except odview.RateLimitError:
            wait_time = (2 ** attempt) + random.uniform(0, 1)
            print(f"Rate limited. Waiting {wait_time:.1f}s...")
            time.sleep(wait_time)
        except odview.ServerError:
            wait_time = 60 + random.uniform(0, 60)
            print(f"Server error. Waiting {wait_time:.0f}s...")
            time.sleep(wait_time)
    raise Exception("Max retries exceeded")

Anti-Patterns to Avoid

Infinite retry loop

Will hammer API, trigger rate limits

Use exponential backoff with max retries

Blocking calls in frontend

Poor user experience, freezes application

Use async/await with loading indicator, webhooks

Hardcoded API keys

Security risk if code is leaked

Use environment variables, secrets management

Recommended Practices

Async webhooks

Non-blocking, scales to 1000s of requests

Use case: Batch processing, background jobs

Cache & reuse

Faster response, reduced API calls

Use case: Common materials, repeated requests

Graceful error handling

Better UX, easier debugging

Use case: Production applications

Official SDKs

Available in 5 languages with full type safety, examples, and documentation.

Python

v2.4.1

50K+/month

pip install odview

Async/await support
Type hints
Error handling
Rate limit aware

JavaScript/TypeScript

v3.1.0

200K+/month

npm install odview

TypeScript support
ESM/CommonJS
Error handling
Browser + Node.js

v1.8.0

15K+/month

go get github.com/odview/go-sdk

Context support
Concurrent requests
Error handling
Full API coverage

Ruby

v2.0.1

8K+/month

gem install odview

Rails integration
Error handling
Async support
Full API coverage

Rust

v0.9.0-betaNew

500+/month

odview = "0.9.0-beta"

Async/await
Type safe
Error handling
Still in beta

Community SDKs & Libraries

The community has built SDKs and wrappers in additional languages.

Kotlin50 C#100 PHP35 Java75

Resources & Support

Everything you need to succeed.

Updated weekly

Complete API Reference

Interactive documentation

100+ endpoint references, Request/response schemas, Authentication guide, Rate limiting details

Real-time

Live Status Page

Real-time monitoring

API availability, Incident history, Performance metrics, Webhook delivery

All systems operational

99.97% uptime (30d)

24/7 available

Developer Support

Get help when you need it

Email support (24h response), Discord community, Stack Overflow, GitHub Issues

Enterprise: <2 hours, Professional: <4 hours

Production Readiness Checklist

Follow these steps to ensure your integration is production-ready.

Progress0/7 complete

Get Your API Key

2 minutes

Install SDK for Your Language

Add the ODview SDK to your project.

5 minutes

Set Up Authentication

Initialize your client with API key.

2 minutes

Generate Your First Material

Make a test API call and verify it works.

5 minutes

Handle Errors Gracefully

Add error handling for production reliability.

10 minutes

Configure Webhooks (Optional)

OPTIONAL

Set up webhooks for async processing at scale.

15 minutes

Deploy to Production

Move from test to live API key and deploy.

Varies

Advanced Features

Power features for production applications.

Batch Processing at Scale

Process 1000s of materials asynchronously

Up to 1000 requests per batch
Webhook notification on completion
Automatic retry on failure
Progress tracking
Cost savings: 10x cheaper

Limits: 500 req/min per API key, 10,000 materials/month on free tier

Use case: Interior design: Generate 500 material variations overnight

Webhooks & Real-time Events

React to events as they happen

Event types: material.created, material.completed, material.failed
Sub-100ms delivery latency
HMAC signature verification
Automatic retry with exponential backoff
At-least-once delivery guarantee

Security: HMAC-SHA256 signatures

Use case: Real-time updates to 3D preview as materials complete

Fine-tuning & Custom Styles

Generate materials matching your brand/style

Coming Q2 2025

Train on custom material library
Generate brand-specific variations
Consistency across projects
Private, dedicated model

Requirements: Minimum 100 reference materials, Enterprise plan required

Use case: Gaming studio: Generate materials matching game's aesthetic

Multi-Material Scenes

Generate complete scenes with coordinated materials

Coming Q3 2025

Generate complementary materials together
Scene composition & layout
Consistency guarantees
Export complete glTF scenes

Limited beta available

Use case: Interior design: Generate entire room with coordinated materials

Simple, Developer-Friendly Pricing

Start free, scale as you grow. No surprise charges.

Free

Perfect for testing

$0/month

10,000 requests/month

(~333/day)

REST API + SDKs
Rate limit: 10 req/min
Community support
Documentation & examples
Email support
Webhooks
Batch processing
Priority queue
Custom SLA

No credit card required

POPULAR

Professional

For growing applications

$99/month

Billed annually: $990 (Save $198/year)

1,000,000 requests/month

(~33,000/day)

REST API + SDKs
Rate limit: 100 req/min
Email support (<4h response)
Webhooks & events
Batch processing (500 per batch)
Priority queue
Monthly reports
Phone support
Custom SLA

Free 14-day trial

Enterprise

For mission-critical applications

Custom

Let's talk about your needs

Unlimited requests

Scale to billions

Everything in Professional
Dedicated account manager
Phone + email support (24/7)
Custom SLA (99.99% available)
Batch processing (unlimited)
Priority queue
Fine-tuning & custom models
On-premises deployment
Advanced analytics

Schedule a demo call

Start Building Now

Join 50,000+ developers building with ODview. Get started in 5 minutes.

Free tier included (10K requests/month)
5-minute quickstart
24/7 developer support
Enterprise-ready APIs

quickstart.py

import odview

client = odview.Client(api_key="sk_...")

material = await client.materials.generate(
    prompt="Weathered oak"
)