Cloud API

Voiceful allows to create new digital voice experiences for web apps, cloud services and digital campaigns. It features speech and singing synthesis, user voice transformation, pitch-correction, time-alignment, audio-to-midi, among others.

Our Cloud API is a RESTful API that can be easily integrated into web sites, mobile apps and other SaaS platforms. We speak PHP, JS, Python, and C++. Contact us for a free evaluation version of Voiceful Cloud API.

PRICING

BASIC

10€ / month
+ 0.04€ / extra request

  • Toolkit features
  • Up to 250 requests included
  • FAQ support

Coming soon

BUSINESS

450€ / month
+ 0.03€ / extra request

  • Toolkit features
  • Up to 15000 requests included
  • Email support

Free evaluation

ENTERPRISE

4500€ / year
+ 0.03€ / extra request

  • Toolkit features
  • Up to 180000 requests included
  • Email/Call support

Free evaluation

A request is the minimal duration unit, corresponding to a single processed or generated audio recording up to 30 seconds. For longer recordings, the number of used requests is counted proportionally.
Payment details: Recurring billing • Cancel anytime

TOOLKIT FEATURES

Voice generation | VoSyn

Our expressive voice generation approach, based on Deep Learning, was initially developed to generate artificial singing voice with high realism. It can learn a model from existing recordings of any individual and generate new speech or singing content. +More info

Voice Transformation | VoTrans

We can transform an actor's voice into a monster vocalization for a film, change a male voice into a kid or elder voice, and integrate it in real-time in games, social apps, or music applications. +More info

Voice Alignment and Pitch Correction | VoAlign

VoAlign analyzes and automatically corrects a voice recording without losing quality. We can align it to a reference recording for lip-syncing or ADR, or apply pitch correction automatically to an estimated musical key.
+More info

Voice Description | VoDesc

This voice analysis tool extracts acoustic and musical information from a voice recording. Data can be sent in real-time, or exported in a readable format to be used in applications such as visualization, classification, monitoring or singing rating. +More info

Time-scaling and Pitch-shifting | VoScale

Beyond voice signals, Voiceful includes also a high-quality time-scaling and pitch-shifting to process any audio content (music, field recordings, dialogues, etc). +More info

Mixing and FX | VoMix

VoMix works as a virtual DAW with all standard audio effects (autogain, compression, EQ, reverb, delay, panning, mixing, etc.) to deliver audio in a professional-like quality. +More info

HOW DOES IT WORK?

Digital and mobile

Voiceful is a toolkit built to design digital and mobile experiences with speech and singing voice. Whether you’re a creative agency, an app developer or a content production company, Voiceful helps you bring to life ideas that include voice interaction and personalization. +More info

Integration

Our API allows to develop ideas and integrate them easily into your app, website, game, social network or products. You can use a Cloud API directly or integrate Voiceful natively in your mobile, desktop or server application. +More info

Pre-set vs Custom

Voiceful combines pre-defined features with a series of elements that can be configured for each project, like language, background music or specific technology adaptation. We can also build ideas from scratch if we love them. Contact us. +More info

Hosting

The content will be processed on our servers, no matter if uploaded by users or generated by Voiceful. It will be available on our storage until expiration date – but you can also extend Voiceful as a storage and distribution option with an extra fee.

DOCUMENTATION

Check our SaaS voice and audio processing tools by trying the below example code.

You can check the full documentation here: https://cloud.voctrolabs.com/docs/api .

                          
  import time
  import requests # sudo pip install requests

  #set user credentials
  user = '[email protected]'
  password = 'yourpassword'

  # Python example that interacts with VOICEFUL VoScale API
  # It creates a new task, starts it and waits until
  # processing have been finished

  url_vocloud = 'https://cloud.voctrolabs.com'

  if __name__ == '__main__':

  # CREATE TASK //////////////////////////////////////////

  print '*** CREATE TASK ***'

  #set parameters for transformation
  timestretch = 0.8;
  pitchshift = 3.0;

  payload = {
  "time_stretch_ratio": timestretch,
  "pitch_shift": pitchshift,
  "audio_upload_parts": 1
  }

  # Post request
  response_create = requests.post(url_vocloud + "/api/voscale/tasks",
  json=payload,
  auth=(user, password))

  print(response_create.json())

  # Then upload (PUT) audio file to S3 url address returned in
  #response_create.json()["audio_upload_urls"][0]
  print "\n*** UPLOAD FILES ***"

  filepath = "test.wav"
  fh = open(filepath)
  audio_data_binary = fh.read()
  response_upload = requests.put(response_create.json()["audio_upload_urls"][0], data=audio_data_binary)

  print("returned ok?:" + str(response_upload.ok) +
  " reason:" + response_upload.reason +
  " status_code:" + str(response_upload.status_code))

  # START TASK ///////////////////////////////////////////
  print "\n*** START TASK ***"
  task_url = url_vocloud + "/api/voscale/tasks/" +
  response_create.json()["id"].encode('utf-8')

  response_start = requests.post(task_url + "/start",
  auth=(user, password))

  print("returned ok?:" + str(response_start.ok) +
  " reason:" + response_start.reason +
  " status_code:" + str(response_start.status_code))

  # Check if task finished
  print "\n*** TASK PROCESSED? ***"

  print "Processing...";
  while True:
  time.sleep(1)  # delays for 1 seconds
  response_status = requests.get(task_url,
  auth=(user, password))

  if response_status.json()["status"] == 'finished' or
  response_status.json()["status"] == 'failed':
  break
  else:
  print '.'

  print "** Output URL: " + response_status.json()['audio_url']

  # Download file
  response_download = requests.get(response_status.json()['audio_url'],
  stream=True)
  if response_download.status_code == 200:
  with open("output.wav", 'wb') as f:
  for chunk in response_download.iter_content(1024):
  f.write(chunk)
                          
                        
                          
  // PHP example that interacts with VOICEFUL VoScale API
  // It creates a new task, starts it and waits until
  // processing have been finished

  //set user credentials
  $user = "[email protected]";
  $password = "yourpassword";

  $url_vocloud = "https://cloud.voctrolabs.com";

  // CREATE TASK //////////////////////////////////////////
  //set parameters for transformation
  $timestretch = 0.8;
  $pitchshift = 3.0;

  $postDataCreate = array(
  'time_stretch_ratio' => $timestretch,
  'pitch_shift' => $pitchshift,
  'audio_upload_parts' => 1
  );

  // Setup cURL
  $chCreate = curl_init($url_vocloud.'/api/voscale/tasks');
  curl_setopt_array($chCreate, array(
  CURLOPT_POST => TRUE,
  CURLOPT_RETURNTRANSFER => TRUE,
  CURLOPT_HTTPHEADER => array(
  'Content-Type: application/json'
  ),

  CURLOPT_POSTFIELDS => json_encode($postDataCreate)
  ));

  curl_setopt($chCreate, CURLOPT_USERPWD, $user . ":" . $password);

  // Send the request
  $responseCreate = curl_exec($chCreate);

  curl_close($chCreate);

  echo "** Response from create task: ********\n".$responseCreate."\n";

  // Check for errors
  if($responseCreate === FALSE){
  die(curl_error($chCreate));
  }

  $responseCreate_obj = json_decode($responseCreate,true);

  // Then upload (PUT) audio file to S3 url address returned
  // in $responseCreate_obj["audio_upload_urls"][0]

  $audio_fn = "test.wav";
  $audio = fopen($audio_fn, "rb");

  $chUpload = curl_init();
  curl_setopt($chUpload, CURLOPT_CONNECTTIMEOUT, 2);
  curl_setopt($chUpload, CURLOPT_HEADER, false);
  curl_setopt($chUpload, CURLOPT_RETURNTRANSFER, 1);
  curl_setopt($chUpload, CURLOPT_BINARYTRANSFER, 1);
  curl_setopt($chUpload, CURLOPT_URL, $responseCreate_obj["audio_upload_urls"][0]);

  curl_setopt($chUpload, CURLOPT_PUT, 1);
  curl_setopt($chUpload, CURLOPT_INFILE, $audio);
  curl_setopt($chUpload, CURLOPT_INFILESIZE, filesize($audio_fn));

  $responseUpload = curl_exec($chUpload);
  curl_close($chUpload);

  echo "\n** Response from upload audio to S3: *****\n".$responseUpload."\n";

  // START TASK ///////////////////////////////////////////
  $task_id = $responseCreate_obj["id"];
  $task_url = $url_vocloud."/api/voscale/tasks/".$task_id;

  // The data to send to the API
  $postDataStart = array(
  'task_url' => $task_url
  );

  // Setup cURL
  $chStart = curl_init($task_url."/start");
  curl_setopt_array($chStart, array(
  CURLOPT_POST => TRUE,
  CURLOPT_RETURNTRANSFER => TRUE,
  CURLOPT_HTTPHEADER => array(
  'Content-Type: application/json'
  ),

  CURLOPT_POSTFIELDS => json_encode($postDataStart)
  ));

  curl_setopt($chStart, CURLOPT_USERPWD, $user . ":" . $password);

  // Send the request
  $responseStart = curl_exec($chStart);
  curl_close($chStart);

  echo "\n** Response from start task: ******\n".$responseStart."\n";

  // Check for errors
  if($responseStart === FALSE){
  die(curl_error($chStart));
  }

  $responseStart_obj = json_decode($responseStart,true);

  echo "\nProcessing...";

  while ( ($responseStatus_obj['status'] != 'failed') and
  ($responseStatus_obj['status'] != 'finished') )
  {
  sleep(1);

  // Setup cURL
  $chStatus = curl_init($task_url);
  curl_setopt($chStatus,CURLOPT_RETURNTRANSFER,true);
  curl_setopt($chStatus, CURLOPT_USERPWD, $user . ":" . $password);
  // Send the request
  $responseStatus = curl_exec($chStatus);
  curl_close($chStatus);

  $responseStatus_obj = json_decode($responseStatus,true);
  echo ".";
  }

  echo "\n\n** Response from status task: ******\n".$responseStatus."\n";

  // Check for errors
  if($responseStatus === FALSE){
  die(curl_error($chStatus));
  }

  //Decode the response
  $responseData_obj = json_decode($responseStatus, TRUE);

  //Print output audio generated
  echo "\n** Output URL: ".$responseData_obj["audio_url"]."\n";

                          
                        
                          
  // C++ example that interacts with VOICEFUL VoScale API
  // It creates a new task, starts it and waits until
  // processing have been finished, downloading the result

  #include <iostream>
  #include "json.hpp" // https://github.com/nlohmann/json
  #include <chrono>
  #include <thread>
  #include <stdlib.h>
  #include <fstream>

  // https://github.com/jpbarrette/curlpp
  #include <curlpp/cURLpp.hpp>
  #include <curlpp/Easy.hpp>
  #include <curlpp/Options.hpp>
  #include <curlpp/Exception.hpp>
  #include <curlpp/Infos.hpp>

  using json = nlohmann::json;

  std::string user = "[email protected]";
  std::string pass = "yourpassword";
  std::string url_vocloud = "https://cloud.voctrolabs.com";

  int main(int argc, const char * argv[]) {

    curlpp::Easy request;
    json payload;

    // set parameters for transformation
    float timestretch = 0.8;
    float pitchshift = 3.0;

    payload = {
        {"time_stretch_ratio", timestretch},
        {"pitch_shift", pitchshift},
        {"audio_upload_parts", 1}
    };

    request.setOpt(new curlpp::options::Url(url_vocloud + "/api/voscale/tasks"));
    std::list<std::string> header;
    header.push_back("Content-Type: application/json");
    request.setOpt(new curlpp::options::HttpHeader(header));
    request.setOpt(new curlpp::options::PostFields(payload.dump()));
    request.setOpt(new curlpp::options::UserPwd(user + ":" + pass));
    std::ostringstream response;
    request.setOpt(new curlpp::options::WriteStream(&response));
    request.perform();

    json response_create = json::parse(response.str());

    std::cout << response.str() << std::endl;

    std::cout << std::endl << "*** UPLOAD FILES ***" << std::endl;

    // Audio 1
    std::string filepath = "test.wav";
    std::string url = response_create["audio_upload_urls"][0];
    request.reset();
    request.setOpt(new curlpp::options::ConnectTimeout(2));
    request.setOpt(new curlpp::options::Header(false));
    request.setOpt(new curlpp::options::Url(url));
    request.setOpt(new curlpp::options::Put(true));
    FILE* wFile;
    wFile = fopen(filepath.c_str(), "rb");
    fseek(wFile, 0, SEEK_END);
    long size = ftell(wFile);
    fseek(wFile, 0, SEEK_SET);
    request.setOpt(new curlpp::options::ReadFile(wFile));
    request.setOpt(new curlpp::options::InfileSize(size));
    request.perform();

    std::cout << "status_code:" << curlpp::infos::ResponseCode::get(request) << std::endl;

    std::cout << "\n*** START TASK ***" << std::endl;
    std::string id = response_create["id"];
    std::string task_url = url_vocloud + "/api/voscale/tasks/" + id;
    std::string start_url = task_url + "/start";
    json payload_start = {{"task_url", task_url}};

    request.reset();
    request.setOpt(new curlpp::options::Url(start_url));
    header.clear();
    header.push_back("Content-Type: application/json");
    request.setOpt(new curlpp::options::HttpHeader(header));
    request.setOpt(new curlpp::options::PostFields(payload_start.dump()));
    request.setOpt(new curlpp::options::UserPwd(user + ":" + pass));
    request.setOpt(new curlpp::options::WriteStream(&response));
    request.perform();

    std::cout << response.str() << std::endl;
    json response_start = json::parse(response.str());

    std::cout << "\n*** TASK PROCESSED? ***" << std::endl;
    json response_status;
    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        request.reset();
        request.setOpt(new curlpp::options::Url(task_url));
        request.setOpt(new curlpp::options::UserPwd(user + ":" + pass));
        request.setOpt(new curlpp::options::WriteStream(&response));
        request.perform();
        response_status = json::parse(response.str());

        if (response_status["status"] == "finished" || response_status["status"] == "failed")
            break;
        else
            std::cout << "-------" << std::endl;
    }

    std::string mixUrl = response_status["audio_url"];
    std::cout << "** Output URL: " << mixUrl << std::endl;

    request.reset();
    request.setOpt(new curlpp::options::Url(url));
    std::ofstream outfile ("output.wav", std::ofstream::binary);
    request.setOpt(new curlpp::options::WriteStream(&outfile));
    request.perform();
    long responseCode = curlpp::infos::ResponseCode::get(request);
    if (responseCode == 200) {
        std::cout << "File written to output.wav" << std::endl;
    } else {
        std::cout << "Error " << responseCode << " downloading file";
        return -1;
    }

    return 0;
  }


                          
                        

Q&A

To configure the Cloud API for a Text-to-Song campaign, we would need an instrumental music track, and the melody either as a music score (MusicXML, MIDI) or as a capella singing performance.
We offer different options starting from 10 EUR/month for 250 requests to generate 30 seconds of singing. For subscription-based apps or services we offer different options. Please contact us to send you a quote.
It depends on the aim of your campaign, preferences and budget. However, with a customized voice, you can have the voice of the artist of your preference. In that case, our team will need the artist to record in a studio a set of musical phrases. We will provide the guidelines and the scripts to be sung. Typically, this can be done in a single studio session. Customized voices will need at least one-week development time. Existing voices, on the other hand, are available on our online demo.
Yes, we have four existing voices in our library, one male and one female in English and Spanish. The four voices can be tested in the online demo and can be used in campaigns.
We are able to provide example code for you to integrate that API, and swap once yours is ready. We can provide the HTML/JS code we use in our demo. We can also provide the server-side examples code in PHP/Python if necessary.
Unfortunately, no, one existing lead vocal tracks of are not sufficient. Creating a customized voice requires several minutes of acapella studio recordings of the artist which should be provided to our team. Contact us for more information.
Yes, we can provide an example where you can listen to the real singer recording and the artificial recreation with melody and song added. You will be surprised with the resemblance! The voice we use as an example is the same that you can try out in the demo.
If voices on our current catalogue are chosen, yes, we can provide two voices in the API for the same price. Otherwise, if the customized option is preferred it is not possible to provide more than one voice for the same fee. Customizing the voice is a complex and intensive R&D process, we can offer discounts in the case two custom voices are needed.
No, we are able to configure servers in different locations if necessary.
Setting up a campaign could take one week; from the date you send the song material. If you want to use the Custom Voice Model (Artist voice), our team will need an extra week to work on it.

No answer? Maybe you're interested in the Standalone SDK or need a custom development!

Our Standalone SDK can be integrated as cross-platform C++ libraries for Mobile (iOS/Android), Desktop or Server applications.

We offer Custom Services to extend and customize our technologies for the specific needs of your project idea.

EVALUATION ACCOUNT

1-month access to Voiceful Cloud API for evaluation

Request us a free evaluation account and obtain the Terms of Use and Pricing information. (Account limited to evaluation purposes and only for professionals: companies, business individuals or research institutions).