# 360 Image Widget Generator (`parseforge/360-image-widget-generator`) Actor

Upload 2-3 photos of an object from different angles and generate 4 or 8 consistent 360-degree spin views. Control camera distance, generation temperature, and style with a custom prompt. Output is a downloadable image sequence ready for any standard 360-viewer widget.

- **URL**: https://apify.com/parseforge/360-image-widget-generator.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** AI, E-commerce, Developer tools
- **Features:** Limited permissions
- **Stats:** 134 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1,600.00 / 1,000 8 views/angles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### 360 Image Widget Generator

**Generate a 360-degree product viewer from 3 static photos.** Upload images of your object from different angles and get back a set of consistent views ready for an interactive spin widget. No 3D modeling skills or special cameras required.

Creating a smooth 360-degree product spin usually means renting a turntable, shooting dozens of frames, and stitching them together in specialized software. This Actor takes 2 or 3 regular photos of your object from different sides and uses AI to generate the missing in-between views. You get a complete image set that can be dropped into any standard 360-image viewer.

| Who uses it | What they scrape 360 Image Widget Generator for |
|---|---|
| E-commerce managers | Create interactive product spins for online store listings without a photo studio. |
| Marketing designers | Generate 360-degree product assets for digital ads and social media campaigns. |
| Product photographers | Offer a 360-spin add-on service using only the standard stills they already shoot. |
| Web developers | Populate 360-viewer components on client sites with AI-generated image sequences. |

### What it does

This Actor generates multiple consistent views of an object from a set of input photos, returning a downloadable archive of images taken from evenly spaced angles around the object.

- 🔄 **Consistent multi-view generation:** Produces 4 or 8 evenly spaced angle views that maintain object identity, colors, and details across all frames.
- 📏 **Adjustable camera distance:** Choose a close, medium, or far framing to control how much of the object and its background fills the shot.
- 🎚️ **Temperature control:** Dial in the balance between strict instruction-following and creative variation for background and detail consistency.
- 📝 **Custom prompt guidance:** Add natural-language instructions to steer the style, lighting, background, or material emphasis of the generated views.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with 360 Image Widget Generator data

**🛒 Boost e-commerce conversions.**

An online store owner uploads three phone photos of a sneaker and generates 8 spin views to embed on the product page, giving shoppers a virtual turn-around experience.

**📱 Enrich social media ads.**

A performance marketer creates a 360-spin of a new gadget from a few press-kit stills and uses the interactive asset in a carousel ad to increase engagement.

**🏠 Preview furniture in context.**

A furniture brand generates 8 views of a chair with a 'far' camera distance and a 'white room' prompt to show the piece in a clean, contextual setting for its catalog.

**🎨 Prototype product variations.**

A product designer feeds concept renders from three angles and uses a custom prompt to explore different material finishes across a full 360-degree spin before committing to production.

### Why choose this scraper

|  | What you get |
|---|---|
| **No turntable needed** | Skip the hardware. Handheld phone photos from a few angles are enough to produce a full spin set. |
| **Consistent object identity** | The AI references all input images for every generated view, so the object stays the same shape and color as it rotates. |
| **Standard viewer output** | The generated image sequence works with any off-the-shelf 360-product-viewer widget or JavaScript library. |
| **Fast iteration** | Change the background, lighting, or distance with a prompt tweak and re-run instead of re-shooting. |

### How it compares

No other Store actor targets 360 Image Widget Generator the same way, so the honest comparison is with the alternatives teams actually weigh.

| | 360 Image Widget Generator | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When 360 Image Widget Generator changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor with 2 or 3 reference photos of the same object, then set the number of output views, camera distance, generation temperature, and an optional custom prompt to control the final look. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "imageUrls": [
    "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/IMG_20240809_074453.jpg",
    "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/IMG_20240809_074519.jpg"
  ],
  "imageCount": "8",
  "distance": "close",
  "temperature": 0.8,
  "customPrompt": "replace background with white room, place toy in a brown wood circular table"
}
```

### Pricing

Pay-per-result: **$2 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $200.00 |
| 1,000 results | $2000.00 |
| 10,000 results | $20000.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [360 Image Widget Generator](https://apify.com/parseforge/360-image-widget-generator?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to 360 Image Widget Generator through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/360-image-widget-generator"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**The generated views do not look like my original object.**

Make sure you uploaded at least 2 clear photos of the same object from different angles. Avoid extreme close-ups or heavy shadows. If the object still drifts, lower the temperature to 0.4 to force stricter adherence to your input images.

**The background changes too much between views.**

Reduce the generation temperature to 0.4 or lower. You can also add a custom prompt like 'keep the background perfectly consistent across all views' to reinforce the requirement.

**My run failed or produced no output.**

Check that your input images are valid JPG, PNG, or WebP files and that you uploaded at least 2 of them. If the issue persists, try a smaller image count (4 instead of 8) and ensure your custom prompt does not contain contradictory instructions.

**The generated images look too similar to each other.**

Increase the temperature slightly to 0.6 or 0.7 to introduce more variation between angles. Also verify that your input photos show genuinely different sides of the object rather than near-identical angles.

### FAQ

| Question | Answer |
|---|---|
| How many input photos do I need? | You need at least 2 images, but 3 images showing different sides of the same object (for example, front, side, and back) give the best results. The Actor uses all uploaded images as reference for every generated view. |
| What image formats are accepted? | You can upload JPG, PNG, or WebP files. Images are automatically optimized before processing, so you do not need to resize them beforehand. |
| How long does a run take? | Generating 4 views typically takes about 2 to 4 minutes, while 8 views takes roughly 4 to 8 minutes. Actual time depends on current platform load and the complexity of your images. |
| Can I control the background of the generated images? | Yes. Use the custom prompt field to describe the background you want, such as 'plain white studio background' or 'wooden table in a sunlit room.' The temperature setting also affects how strictly the background stays consistent across views. |
| Will the object look exactly the same in every generated view? | The AI references all your input photos to maintain consistent object identity, colors, and details. A lower temperature value (0.4 to 0.6) helps keep the object and background more uniform across all angles. |
| What can I do with the output images? | The generated image sequence is ready for any standard 360-product-viewer widget. You can embed it on a website, use it in a mobile app, or include it in a digital catalog that supports interactive spin functionality. |
| Does the Actor work with reflective or transparent objects? | The AI model handles a wide range of products, but highly reflective surfaces like mirrors or completely transparent glass can sometimes produce inconsistent reflections. Providing clear, well-lit input photos helps improve the result. |
| What does the temperature setting do? | Temperature controls how strictly the AI follows your instructions versus introducing creative variation. Lower values (0.1 to 0.4) produce more consistent backgrounds and details, while higher values (0.8 to 1.0) allow more variation. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Apify. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `imageUrls` (type: `array`):

Upload one or more images of the SAME object from different angles. This helps the AI understand the complete 3D structure, features, colors, and details of your object.

📸 How it affects output:
• All input images are used as reference for every generated view to maintain consistency
• Images are automatically optimized before processing
• Works best with 3 input pictures showing different sides of your object

💡 Tip: Upload 3 images showing different sides of your object (e.g., front, side, back) for best results.

Supported formats: JPG, PNG, WebP

## `imageCount` (type: `string`):

Choose how many angle views to generate around your object. This determines the smoothness of the 360° rotation in your widget.

📸 How it affects output:
• More views = Smoother rotation experience = More processing time
• Fewer views = Faster generation = Less smooth rotation

✅ 4 Images (every 90°)
Generates: Front (0°), Right (90°), Back (180°), Left (270°)
Best for: Quick previews, simple objects
Processing time: ~2-4 minutes

✅ 8 Images (every 45°)
Generates: Front, Front-Right, Right, Back-Right, Back, Back-Left, Left, Front-Left
Best for: Professional product showcases, smooth rotation
Processing time: ~4-8 minutes

💡 Recommended: 8 images for the best balance of quality and smoothness.

## `distance` (type: `string`):

Control how close or far the camera appears from your object in all generated views. This affects the framing and how much background is visible.

📸 How it affects output:
• Close: Object fills more of the frame, less background visible, great for detail shots
• Medium: Balanced view, object and background both visible, recommended for most products
• Far: Object appears smaller, more background visible, shows context and environment

✅ Close
Effect: Camera is very close to the object
Best for: Detail-focused products, jewelry, small items
Object size: Large in frame
Background: Minimal

✅ Medium (Recommended)
Effect: Camera at comfortable viewing distance
Best for: Most products, general use cases
Object size: Balanced
Background: Moderate

✅ Far
Effect: Camera is far from the object
Best for: Showing context, environment, large items in setting
Object size: Smaller in frame
Background: Extensive

💡 All views maintain the same distance - only the angle changes around the object.

## `temperature` (type: `number`):

Control how strictly the AI follows instructions versus being creative. This affects consistency and adherence to your requirements.

📸 How it affects output:
• Lower temperature (0.1-0.4): More consistent, strictly follows instructions, better background consistency, less variation
• Medium temperature (0.5-0.7): Balanced approach, good consistency with some flexibility
• Higher temperature (0.8-1.0): More creative, may vary more, less strict adherence

⚠️ Too Low (below 0.3):
• May be too rigid and repetitive
• Could produce very similar images across angles
• Might miss some creative details
• Best for: Maximum consistency when background must be identical

✅ Recommended (0.4-0.6):
• Good balance of consistency and quality
• Follows instructions well while maintaining natural appearance
• Best for: Most use cases, professional product showcases

⚠️ Too High (above 0.7):
• May introduce unwanted variations
• Background consistency might suffer
• Could deviate from angle requirements
• Best for: Creative variations when strict consistency isn't critical

💡 Default: 0.5 provides the best balance for most products.

## `customPrompt` (type: `string`):

Add specific instructions to customize how your 360° views are generated. These instructions are combined with the standard requirements.

📸 How it affects output:
• Your instructions guide the AI's generation style and focus
• Use for specific styling, background preferences, or special requirements
• Leave empty to use default professional settings

💡 Example instructions:
• "Keep the background minimal and clean"
• "Emphasize product details and textures"
• "Maintain professional studio lighting"
• "Show the object in a natural environment"
• "Keep colors vibrant and saturated"
• "Use soft, diffused lighting"

⚠️ Note: Instructions should complement, not contradict, the standard requirements (like maintaining background consistency).

## Actor input object example

```json
{
  "imageUrls": [
    "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/IMG_20240809_074453.jpg",
    "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/IMG_20240809_074519.jpg"
  ],
  "imageCount": "8",
  "distance": "close",
  "temperature": 0.8,
  "customPrompt": "replace background with white room, place toy in a brown wood circular table"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "imageUrls": [
        "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/IMG_20240809_074453.jpg",
        "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/IMG_20240809_074519.jpg"
    ],
    "imageCount": "8",
    "distance": "close",
    "temperature": 0.8,
    "customPrompt": "replace background with white room, place toy in a brown wood circular table"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/360-image-widget-generator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "imageUrls": [
        "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/IMG_20240809_074453.jpg",
        "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/IMG_20240809_074519.jpg",
    ],
    "imageCount": "8",
    "distance": "close",
    "temperature": 0.8,
    "customPrompt": "replace background with white room, place toy in a brown wood circular table",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/360-image-widget-generator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "imageUrls": [
    "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/IMG_20240809_074453.jpg",
    "https://api.apify.com/v2/key-value-stores/S8l2sknfAAra9YPZ7/records/IMG_20240809_074519.jpg"
  ],
  "imageCount": "8",
  "distance": "close",
  "temperature": 0.8,
  "customPrompt": "replace background with white room, place toy in a brown wood circular table"
}' |
apify call parseforge/360-image-widget-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/360-image-widget-generator"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/2Rqzc8WmbVF1vVAni/builds/3aGCgarq7bYFfUKP5/openapi.json