Generate and save IllyVoIP speech audio in Make

Connect Make’s HTTP module to IllyVoIP Text-to-Speech, then convert the successful response’s audio_base64 field into binary file data. The synthesis response is JSON: saving that response directly as an MP3 creates a text file with the wrong extension.

Before you build the scenario

You need a Make scenario, a private IllyVoIP API key, account access to standalone speech synthesis and a destination module that can upload a file. This guide uses Make HTTP version 4 and an existing file-storage connection. There is no native IllyVoIP Make module assumed here. Review current speech pricing: synthesis can incur a character-based charge.

Use text that your application genuinely needs to turn into speech, such as a short approved service announcement. IllyVoIP call recordings already have their own integrated transcript and summary workflow; do not download and reprocess those recordings for this scenario.

1. Store the API key in the HTTP connection

1. Add HTTP → Make a request. Choose API key authentication and create a private keychain/credential.
2. Configure the credential to send your secret in the X-Api-Key header. Do not place the key in the URL, a public scenario note or an ordinary mapped message field.
3. Use the HTTPS API host api.illyvoip.com. Keep the scenario’s inputs and execution history private if the text includes customer information.

2. Select a current language and voice

Use GET requests to /api/v1/tts/languages and then /api/v1/tts/voices. Send context=speech_api to both, and the chosen language to the voices request. Enable Parse response and inspect the returned catalog. Copy the exact voice key, not just its display label. A voice available in a different speech context is not automatically a valid choice here.

3. Build the synthesis request

Add another HTTP request with method POST and path /api/v1/tts/synthesize. Select application/JSON and build a data structure so mapped text is escaped correctly. Use these fields:

{
  "text": "Your approved service announcement.",
  "language": "CHOOSE_FROM_LANGUAGE_CATALOG",
  "voice": "CHOOSE_FROM_VOICE_CATALOG",
  "format": "mp3",
  "sample_rate_hz": 22050,
  "channels": 1
}

Replace both catalog placeholders before execution. Text is limited to 2,000 characters per request. The supported formats are MP3 and WAV, sample rate is 8,000–48,000 Hz, and channels is 1 or 2. Choose values your eventual player accepts. Do not automatically split arbitrary long text into many paid requests.

4. Filter the response before creating a file

Configure the HTTP module to report failed requests and parse the JSON. Continue to file storage only when the response indicates status: success, a supported mime_type, and nonempty audio_base64. Route errors to review rather than treating their JSON body as audio. An HTTP timeout leaves uncertainty; it is not permission to regenerate a new paid request indefinitely.

5. Map binary audio into the upload module

In your chosen storage module’s file-data field, map the synthesis module’s audio_base64 value through Make’s binary conversion:

toBinary(audio_base64; base64)

Here audio_base64 represents the mapped response token, not the literal text to type into the function. Choose a filename ending in .mp3 for an MP3 response or .wav for a WAV response. Do not apply base64() again: that encodes text instead of decoding the audio.

Use a unique file name or an explicit overwrite policy so a rerun does not silently replace an approved prompt. After upload, save the storage file ID alongside your own logical synthesis request and request settings. A stored JSON response is useful for recovery but is not the playback file.

6. Verify once before enabling automation

First test the mapping with a synthetic known-good audio response, then run one deliberately authorized short synthesis. Play the stored file and check wording, voice, duration and format. Confirm that a failed response creates no audio file. Enable scheduling only after deciding how repeated scenario runs, interrupted uploads and uncertain synthesis outcomes are reconciled.

If the file will not play, inspect response status, MIME type, base64 mapping and the upload module’s binary field before changing voice settings. If authentication fails, fix the private credential. If a voice is rejected, refresh the standalone catalog. Keep keys and generated private text out of shared execution screenshots.

Related guides

• Convert text to speech with the IllyVoIP API and save the audio
• Send an IllyVoIP SMS from a Make.com scenario
• Start with the API, Playground and webhooks

Reference

Current instructions and technical reference: Make HTTP module, Make text and binary functions.

Reviewed 12 October 2026 against the current IllyVoIP controls, implementation and applicable references. Available options depend on account permissions and service state.