> ## Documentation Index
> Fetch the complete documentation index at: https://gigareels.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Basic Render Example

> Simple examples of generating content with GigaReels

# Basic Render Examples

Get started with these simple examples showing how to generate different types of content using GigaReels.

## Educational Brainrot Video

Generate an educational video with character dialogues:

```javascript theme={null}
import { GigaReels } from "@gigareels/sdk";

const client = new GigaReels("your-api-key");

async function generateEducationalVideo() {
	try {
		const task = await client.templates.brainrot.educational({
			prompt: "Explain how photosynthesis works in plants and why it's important for life on Earth",
			characterPack: "rick-and-morty",
			backgroundVideoPack: "minecraft-parkour",
			enableGifs: true,
			webhookUrl: "https://your-app.com/webhook", // Optional
		});

		console.log("✅ Video generation started!");
		console.log("Task ID:", task.taskId);
		console.log("Status:", task.status);

		if (task.outputUrl) {
			console.log("🎬 Video URL:", task.outputUrl);
		}

		return task;
	} catch (error) {
		console.error("❌ Error generating video:", error.message);
		throw error;
	}
}

generateEducationalVideo();
```

## Breaking News Video

Create a viral news-style video:

```javascript theme={null}
async function generateBreakingNews() {
	const task = await client.templates.brainrot.newsFish({
		searchTerm: "Scientists discover plants can actually hear music and prefer jazz!",
		webhookUrl: "https://your-app.com/webhook",
	});

	console.log("📺 Breaking news video started:", task.taskId);
	return task;
}
```

## Text Message Conversation

Generate an iPhone-style conversation video:

```javascript theme={null}
async function generateTextConversation() {
	const task = await client.templates.brainrot.iMessage({
		prompt:
			"Create a funny conversation between two roommates where one discovers the other has been using their Netflix account to watch nothing but cooking shows",
		characterPack: "family-guy",
		backgroundVideoPack: "subway-surfers",
		enableImages: true,
	});

	console.log("💬 Text conversation video started:", task.taskId);
	return task;
}
```

## Transform Existing Video

Modify an existing video to bypass duplicate detection:

```javascript theme={null}
async function transformVideo() {
	const task = await client.templates.utilities.transform({
		videoUrl: "https://your-bucket.com/original-video.mp4",
		enableDistortionBar: true,
		audioPitchDistortion: 0.15,
		framesToKill: 25,
	});

	console.log("🎭 Video transformation started:", task.taskId);
	return task;
}
```

## Complete Workflow with Error Handling

Here's a more complete example with proper error handling:

```javascript theme={null}
import { GigaReels, ValidationError } from "@gigareels/sdk";

class VideoGenerator {
	constructor(apiKey) {
		this.client = new GigaReels(apiKey);
	}

	async generateWithRetry(renderFunction, maxRetries = 3) {
		for (let attempt = 1; attempt <= maxRetries; attempt++) {
			try {
				return await renderFunction();
			} catch (error) {
				console.log(`Attempt ${attempt} failed:`, error.message);

				if (error instanceof ValidationError) {
					// Don't retry validation errors
					throw error;
				}

				if (attempt === maxRetries) {
					throw error;
				}

				// Wait before retrying
				await new Promise(resolve => setTimeout(resolve, 2000 * attempt));
			}
		}
	}

	async generateEducationalContent(topic) {
		return this.generateWithRetry(async () => {
			return await this.client.templates.brainrot.educational({
				prompt: `Explain ${topic} in an engaging way for a young audience. Make it educational but fun.`,
				characterPack: "rick-and-morty",
				backgroundVideoPack: "minecraft-parkour",
				enableGifs: true,
			});
		});
	}

	async generateNews(headline) {
		return this.generateWithRetry(async () => {
			return await this.client.templates.brainrot.newsFish({
				searchTerm: headline,
			});
		});
	}

	async checkTaskStatus(taskId) {
		try {
			const status = await this.client.getTaskStatus(taskId);
			return status;
		} catch (error) {
			console.error("Error checking task status:", error.message);
			throw error;
		}
	}
}

// Usage example
async function main() {
	const generator = new VideoGenerator(process.env.GIGAREELS_API_KEY);

	try {
		// Generate educational content
		console.log("🎬 Generating educational video...");
		const educationalTask = await generator.generateEducationalContent("quantum physics");
		console.log("✅ Educational video:", educationalTask.taskId);

		// Generate breaking news
		console.log("📺 Generating news video...");
		const newsTask = await generator.generateNews("AI robots learn to make perfect pizza!");
		console.log("✅ News video:", newsTask.taskId);

		// Check status after some time
		setTimeout(async () => {
			const educationalStatus = await generator.checkTaskStatus(educationalTask.taskId);
			console.log("📊 Educational video status:", educationalStatus.status);

			if (educationalStatus.outputUrl) {
				console.log("🎉 Educational video completed:", educationalStatus.outputUrl);
			}
		}, 60000); // Check after 1 minute
	} catch (error) {
		if (error instanceof ValidationError) {
			console.error("❌ Validation Error:");
			error.issues.forEach(issue => {
				console.error(`  - ${issue.path.join(".")}: ${issue.message}`);
			});
		} else {
			console.error("❌ Unexpected Error:", error.message);
		}
	}
}

main();
```

## Batch Generation

Generate multiple videos in parallel:

```javascript theme={null}
async function generateBatch() {
	const client = new GigaReels(process.env.GIGAREELS_API_KEY);

	const topics = [
		"How do black holes work?",
		"Why do we dream when we sleep?",
		"What makes music sound good?",
		"How do vaccines protect us?",
	];

	try {
		// Start all generations in parallel
		const tasks = await Promise.all(
			topics.map(topic =>
				client.templates.brainrot.educational({
					prompt: topic,
					characterPack: "rick-and-morty",
					backgroundVideoPack: "minecraft-parkour",
					enableGifs: true,
					webhookUrl: "https://your-app.com/webhook",
				})
			)
		);

		console.log("🚀 Started", tasks.length, "video generations:");
		tasks.forEach((task, index) => {
			console.log(`  ${index + 1}. ${topics[index]} -> ${task.taskId}`);
		});

		return tasks;
	} catch (error) {
		console.error("❌ Batch generation failed:", error.message);
		throw error;
	}
}

generateBatch();
```

## Environment-Specific Configuration

Set up different configurations for different environments:

```javascript theme={null}
class EnvironmentConfig {
	static getConfig() {
		const env = process.env.NODE_ENV || "development";

		const configs = {
			development: {
				apiKey: process.env.GIGAREELS_DEV_API_KEY,
				baseUrl: "http://localhost:3000",
				webhookUrl: "http://localhost:3001/webhook",
			},
			staging: {
				apiKey: process.env.GIGAREELS_STAGING_API_KEY,
				baseUrl: "https://staging-api.gigareels.com",
				webhookUrl: "https://staging.yourapp.com/webhook",
			},
			production: {
				apiKey: process.env.GIGAREELS_API_KEY,
				baseUrl: "https://gigareels.com",
				webhookUrl: "https://yourapp.com/webhook",
			},
		};

		return configs[env] || configs.development;
	}

	static createClient() {
		const config = this.getConfig();
		return new GigaReels({
			apiKey: config.apiKey,
			baseUrl: config.baseUrl,
		});
	}
}

// Usage
const client = EnvironmentConfig.createClient();
const config = EnvironmentConfig.getConfig();

const task = await client.templates.brainrot.educational({
	prompt: "Explain renewable energy",
	characterPack: "rick-and-morty",
	backgroundVideoPack: "minecraft-parkour",
	webhookUrl: config.webhookUrl,
});
```

## Next Steps

> [card] [Batch Rendering](https://gigareels.mintlify.site/examples/batch-rendering)
>
> Learn how to generate multiple videos efficiently

> [card] [Social Media Integration](https://gigareels.mintlify.site/examples/social-posting)
>
> Automatically upload generated content to social platforms

> [card] [Webhook Handling](https://gigareels.mintlify.site/examples/webhooks)
>
> Set up webhooks for async video processing

> [card] [Advanced Templates](https://gigareels.mintlify.site/render-types/overview.md)
>
> Explore all available render types and customization options

> [!TIP]
>
> **Pro Tip**: Always use webhooks in production to avoid blocking your application while videos are
> being generated. Video generation typically takes 2-5 minutes.

&#x20;


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.