SDKs and Libraries - Posternity Documentation

Overview

Our official SDKs and libraries provide easy-to-use interfaces for integrating Posternity's AI capabilities into your applications. Each SDK is designed with best practices, comprehensive error handling, and extensive documentation.

                            SDK Benefits
                            Easy Integration — Simple APIs with comprehensive documentation
Type Safety — Full TypeScript support and type definitions
Error Handling — Robust error handling and retry logic
Async Support — Built-in support for asynchronous operations
Testing — Comprehensive test suites and mocking utilities
Performance — Optimized for high-volume operations

                        

Studio SDKs for Agencies

Creative Agency Development

Specialized SDKs designed for creative agencies, marketing teams, and design professionals with workflow optimization and client management features.

Python SDK Python 3.8+

Comprehensive Python SDK with specialized Studio and Map modules for agency workflows and enterprise operations.

Installation

pip install posternity-sdk
from posternity import Studio, Map
Configure your API key

# Studio SDK Example
from posternity import Studio

studio = Studio(api_key="your_api_key")

# Generate campaign assets
campaign = studio.create_campaign({
    "name": "Summer Collection 2024",
    "client": "Fashion Brand",
    "assets": [
        {"type": "banner", "prompt": "Summer fashion banner"},
        {"type": "social", "prompt": "Instagram post design"}
    ]
})

# Process with brand guidelines
result = campaign.generate_with_brand_guidelines({
    "colors": ["#FF6B6B", "#4ECDC4"],
    "fonts": ["Montserrat", "Open Sans"],
    "style": "modern-minimal"
})
                            

JavaScript/Node.js SDK Node.js 16+

Full-featured JavaScript SDK with TypeScript support, perfect for web applications and server-side integrations.

Installation

npm install @posternity/sdk
import { Studio, Map } from '@posternity/sdk'
Configure your API key

// Studio SDK Example
import { Studio } from '@posternity/sdk';

const studio = new Studio({
  apiKey: 'your_api_key',
  environment: 'production'
});

// Create client project
const project = await studio.createProject({
  name: 'Brand Campaign 2024',
  client: 'Tech Startup',
  brandGuidelines: {
    primaryColor: '#3B82F6',
    secondaryColor: '#10B981',
    typography: 'Inter'
  }
});

// Generate assets with approval workflow
const assets = await project.generateAssets([
  { type: 'logo', prompt: 'Modern tech logo' },
  { type: 'banner', prompt: 'Product launch banner' }
], {
  approvalRequired: true,
  stakeholders: ['client@company.com', 'designer@agency.com']
});
                            

Map SDKs for Enterprises

Enterprise Geographic Solutions

Advanced SDKs for enterprise applications requiring geographic content generation, location intelligence, and multi-region operations.

Java SDK Java 11+

Enterprise-grade Java SDK with comprehensive geographic features and enterprise security standards.

Installation

Add to pom.xml or build.gradle
import com.posternity.Map;
Configure enterprise settings

// Map SDK Example
import com.posternity.Map;
import com.posternity.model.GeographicRegion;

Map map = new Map.Builder()
    .apiKey("your_api_key")
    .enterpriseMode(true)
    .securityLevel("high")
    .build();

// Generate content for multiple regions
List<GeographicRegion> regions = Arrays.asList(
    new GeographicRegion("europe", "germany", "berlin"),
    new GeographicRegion("asia", "japan", "tokyo"),
    new GeographicRegion("americas", "usa", "new-york")
);

MapContentResult result = map.generateRegionalContent(
    "Product launch campaign",
    regions,
    MapOptions.builder()
        .culturalAdaptation(true)
        .languageLocalization(true)
        .complianceCheck(true)
        .build()
);
                            

C# SDK .NET 6+

Microsoft .NET SDK with enterprise features, Azure integration, and comprehensive geographic capabilities.

Installation

dotnet add package Posternity.Sdk
using Posternity;
Configure Azure integration

// Map SDK Example
using Posternity;
using Posternity.Models;

var map = new MapClient(new MapOptions
{
    ApiKey = "your_api_key",
    Environment = Environment.Production,
    EnterpriseMode = true
});

// Geographic content generation
var regions = new[]
{
    new GeographicRegion("Europe", "Germany", "Berlin"),
    new GeographicRegion("Asia", "Japan", "Tokyo")
};

var result = await map.GenerateRegionalContentAsync(
    "Global marketing campaign",
    regions,
    new MapGenerationOptions
    {
        CulturalAdaptation = true,
        LanguageLocalization = true,
        ComplianceCheck = true,
        AnalyticsTracking = true
    }
);
                            

Mobile SDKs

iOS SDK Swift 5.5+

Native iOS SDK with SwiftUI support, Core ML integration, and offline capabilities for mobile applications.

Installation

Add via Swift Package Manager
import PosternitySDK
Configure in AppDelegate

// iOS SDK Example
import PosternitySDK

let studio = Studio(apiKey: "your_api_key")

// Generate content for mobile app
let request = ContentRequest(
    prompt: "Mobile app hero image",
    style: .modern,
    dimensions: .mobile
)

studio.generateContent(request) { result in
    switch result {
    case .success(let content):
        // Handle generated content
        DispatchQueue.main.async {
            self.updateUI(with: content)
        }
    case .failure(let error):
        // Handle error
        print("Error: \(error.localizedDescription)")
    }
}
                            

Android SDK Java/Kotlin

Native Android SDK with Kotlin support, Jetpack Compose integration, and Material Design components.

Installation

Add to build.gradle
import com.posternity.sdk
Initialize in Application class

// Android SDK Example
import com.posternity.sdk.Studio
import com.posternity.sdk.models.ContentRequest

val studio = Studio.Builder()
    .apiKey("your_api_key")
    .build()

// Generate content with Material Design
val request = ContentRequest.Builder()
    .prompt("Android app banner")
    .style(Style.MATERIAL)
    .dimensions(Dimensions.MOBILE)
    .build()

studio.generateContent(request) { result ->
    result.onSuccess { content ->
        // Update UI on main thread
        runOnUiThread {
            updateUI(content)
        }
    }.onFailure { error ->
        // Handle error
        Log.e("Posternity", "Error: ${error.message}")
    }
}
                            

Web Libraries

React Library React 18+

React components and hooks for seamless integration of Posternity features into React applications.

// React Library Example
import { PosternityProvider, useStudio } from '@posternity/react';

function App() {
  return (
    <PosternityProvider apiKey="your_api_key">
      <ContentGenerator />
    </PosternityProvider>
  );
}

function ContentGenerator() {
  const { generateImage, isLoading } = useStudio();
  
  const handleGenerate = async () => {
    const result = await generateImage({
      prompt: "Beautiful landscape",
      style: "photorealistic"
    });
    console.log(result);
  };
  
  return (
    <button onClick={handleGenerate} disabled={isLoading}>
      {isLoading ? 'Generating...' : 'Generate Image'}
    </button>
  );
}
                            

Vue.js Library Vue 3+

Vue.js composables and components for building interactive content generation interfaces.

// Vue.js Library Example
import { createApp } from 'vue';
import { createPosternity } from '@posternity/vue';

const app = createApp(App);
app.use(createPosternity({
  apiKey: 'your_api_key'
}));

// In component
import { useStudio } from '@posternity/vue';

export default {
  setup() {
    const { generateImage, isLoading } = useStudio();
    
    const handleGenerate = async () => {
      const result = await generateImage({
        prompt: "Vue.js application banner",
        style: "modern"
      });
    };
    
    return { handleGenerate, isLoading };
  }
}
                            

Advanced Features

Webhook Integration

Built-in webhook handling for real-time notifications and async operation management across all SDKs.

Batch Operations

Efficient batch processing for high-volume content generation with progress tracking and error handling.

Offline Support

Offline capabilities for mobile SDKs with local caching and sync when connectivity is restored.

Enterprise Security

Advanced security features including encryption, audit logging, and compliance with enterprise standards.

Getting Started

Choose Your SDK — Select the appropriate SDK for your platform and use case
Install Dependencies — Follow the installation instructions for your chosen SDK
Get API Key — Obtain your API key from the Posternity dashboard
Configure SDK — Initialize the SDK with your API key and preferences
Start Building — Begin integrating Posternity features into your application

SDK Support

Need help with SDK integration? Our developer support team provides comprehensive assistance for all official SDKs, including custom implementations for enterprise clients.