# Procedural SFX & Scene Composer (`invincible_nova/procedural-sfx-pack-generator`) Actor

Generate fresh, sample-free WAV sound effects and short scenes for apps, games, and motion design. Choose 12 procedural sound families or mix up to 8 cues. Seeded, reproducible output with ZIP, stems, cue sheet, and JSON metadata. No external audio API.

- **URL**: https://apify.com/invincible_nova/procedural-sfx-pack-generator.md
- **Developed by:** [Sergei Pechenov](https://apify.com/invincible_nova) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Procedural SFX & Scene Composer

Generate fresh, sample-free sound effects for UI prototypes, simple games, and motion graphics. Choose individual sound families for a WAV pack, or combine supported cues into a short scene. The sound is synthesized mathematically inside the Actor: no external audio-generation API, downloaded samples, or speech model is used.

### What you get

- **Sound pack:** 1–12 sound families, with 1–3 structurally different variants each (up to 36 WAV files). Available families: `ui_click`, `ui_confirm`, `ui_error`, `ui_notification`, `coin`, `jump`, `laser`, `hit`, `explosion`, `whoosh`, `bell`, and `ambient_drone`.
- **Short scene:** a 2–12 second mixed WAV with 1–8 supported cues, plus a cue sheet and individual cue stems in a ZIP. You can provide a short English/Russian description or an explicit timeline.
- **Inspectable output:** `SFX_PACK.zip`, `MANIFEST` JSON, `OUTPUT` JSON, and a Dataset row per generated sound or scene cue. In scene mode, `SCENE.wav` is also available directly.

All audio is 44.1 kHz, mono, 16-bit PCM WAV. The same seed and settings reproduce byte-identical output within the same engine/runtime build; later engine versions may change the result. Preserve the manifest and hashes if exact reproducibility matters.

### Quick start

Generate all 12 families with three variants each (the default input):

```json
{"mode":"pack","seed":"my-ui-pack","variants":3}
```

Generate only selected sounds:

```json
{"mode":"pack","seed":"game-01","presets":["coin","jump","laser","hit","explosion"],"variants":2}
```

Compose a short scene from recognized words:

```json
{"mode":"scene","seed":"demo-scene-01","sceneDurationSeconds":5,"sceneDescription":"Low drone, then a notification, laser and explosion"}
```

For predictable timing, an agent or developer can supply an explicit plan instead:

```json
{
  "mode":"scene",
  "seed":"demo-scene-01",
  "scenePlan":{
    "durationSeconds":5,
    "cues":[
      {"preset":"ambient_drone","variant":1,"atSeconds":0,"gainDb":-11,"loop":true},
      {"preset":"ui_notification","variant":2,"atSeconds":1,"gainDb":-5},
      {"preset":"explosion","variant":3,"atSeconds":3,"gainDb":-6}
    ]
  }
}
```

### Finding your files

Open the run's **Output** tab to download the ZIP or read `OUTPUT`. The ZIP contains every WAV in pack mode. In scene mode it contains `scene.wav`, `cue-sheet.json`, and a `stems/` folder. The Dataset contains metadata for each generated item; it is **not** the binary audio itself. The key-value store holds `SFX_PACK.zip`, `MANIFEST`, `OUTPUT`, and in scene mode `SCENE.wav`.

For automated workflows, inspect `OUTPUT.status`, `mode`, the file keys, and Dataset rows. In scene mode, inspect `unsupportedCues` and `unparsedWords` before treating the result as complete. Use the manifest's SHA-256 hashes when you need to verify a download.

### Important limits

This is a controlled procedural synth, **not** general text-to-audio or realistic Foley. Free-text scene planning recognizes only the 12 listed sound families. It follows their order in the description and spreads foreground sounds across the duration; words such as “then” do not define exact timestamps. It cannot synthesize dialogue, animal sounds, rain, wind, footsteps, doors, vehicles, or music. Known unsupported concepts and other unparsed words are reported, and `OUTPUT.status` becomes `partial` if at least one supported cue was rendered. A description with no supported cue is rejected instead of producing a misleading file. Use `scenePlan` for precise cue placement, but it still supports only the same 12 families.

The current output is intentionally mono WAV, not MP3 or stereo. Up to eight cues and twelve seconds keep runs bounded. The Actor does not upload audio to any third-party sound service. Apify still stores the generated files as part of the run and charges for platform usage under your Apify plan.

# Actor input Schema

## `mode` (type: `string`):

Pack: individual sounds. Scene: one mixed WAV from a description or explicit cue plan.

## `seed` (type: `string`):

Repeat the same seed and settings on the same engine/runtime build to get byte-identical WAV and ZIP outputs.

## `presets` (type: `array`):

Pack mode only. Choose one or more effects; omit to generate all 12.

## `variants` (type: `integer`):

Pack mode only. One to three controlled variants for each selected preset.

## `sceneDescription` (type: `string`):

Scene mode only. Limited RU/EN vocabulary of the 12 presets; unsupported rain, speech, footsteps etc. are reported, not faked. Example: 'Низкий гул, затем сигнал, лазер и взрыв'.

## `sceneDurationSeconds` (type: `number`):

Scene mode only. Duration of the mixed WAV.

## `scenePlan` (type: `object`):

Scene mode only. Optional precise JSON plan: {durationSeconds, cues:\[{preset,variant,atSeconds,gainDb,loop}]}. Overrides sceneDescription.

## Actor input object example

```json
{
  "mode": "pack",
  "seed": "demo-2026",
  "variants": 3,
  "sceneDurationSeconds": 5
}
```

# Actor output Schema

## `pack` (type: `string`):

No description

## `manifest` (type: `string`):

No description

## `sounds` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `files` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("invincible_nova/procedural-sfx-pack-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("invincible_nova/procedural-sfx-pack-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 '{}' |
apify call invincible_nova/procedural-sfx-pack-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,invincible_nova/procedural-sfx-pack-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/RsdmzgberrimZI2Xk/builds/W3e45ucdXp2dC34mV/openapi.json