How to Migrate Your Java Voice Application from Twilio to Plivo

Dec 13, 2021

Migrating from Twilio to Plivo is a seamless and painless process. The two companies’ API structures, implementation mechanisms, XML structure, SMS message processing, and voice call processing are similar. We wrote this technical comparison between Twilio and Plivo APIs so that you can scope the code changes for a seamless migration.

Understanding the differences between Twilio and Plivo development

Most of the APIs and features that are available on Twilio are also available on Plivo and the implementation mechanism is easier as the steps involved are almost identical. This table gives a side-side comparison of the two companies’ features and APIs. An added advantage with Plivo is that not only can you code using the old familiar API/XML method, you can also implement your use cases using PHLO (Plivo High Level Objects), a visual workflow builder that lets you create workflows by dragging and dropping components onto a canvas — no coding required.

Features and APIs	Twilio	Plivo	Similarities	Implementation Interface
Voice API: Make phone calls	✅	✅	Request and response variables’ structure	API PHLO
Programmatically manage call flows	Twiml	Plivo XML	XML element and its attributes structure	XML PHLO
Geo Permissions	✅	✅	Feature parity	Console
Number Lookup API	✅	✅	API Parity	API
Phone number management	✅	✅	Feature parity	API Console
Call Insights	✅	✅	Feature parity	Console
Validating Requests	✅	✅	Feature parity	API XML
Subaccounts	✅	✅	Feature parity	API
Speech recognition	✅	✅	Feature parity	XML
SSML (Speech Synthesis Markup Language)	✅	✅	Feature parity	XML PHLO
Browser and Mobile SDKs	✅	✅	Feature parity	Browser Android iOS
Transcription	✅	✅	Feature parity	API XML PHLO
Custom SIP Headers	✅	✅	Feature parity	API XML PHLO Browser SDK Mobile SDKs
HTTP callbacks	✅	✅	Feature parity	API XML PHLO

Plivo account creation

Start by signing up for a free trial account that you can use to experiment with and learn about our services. The free trial account comes with free credits, and you can add more as you go along. You can also add a phone number to your account to start testing the full range of our voice and SMS features. A page in our support portal walks you through the signup process.

You can also port your numbers from Twilio to Plivo, as we explain in this guide.

Migrating your Voice application

As mentioned earlier, you can migrate your existing application from Twilio to Plivo by refactoring the code, or you can try our intuitive visual workflow builder PHLO. If you prefer the API approach, you can follow one of the voice quickstart guides based on your preferred language and web framework. Plivo offers server SDKs in seven languages: Python, Node.js, .NET, Java, Python, Ruby, and Go. For another alternative that lets you evaluate Plivo’s SMS APIs and their request and response structure, use our Postman collections.

How to make an outbound call

Let’s take a look at the process of refactoring the code to migrate your app from Twilio to Plivo to set up a simple Java application to make an outbound call by changing just a few lines of code.

Twilio Plivo

import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Call;
import com.twilio.type.PhoneNumber;

import java.net.URI;

public class Example {
public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");
public static final String AUTH_TOKEN = System.getenv("TWILIO_AUTH_TOKEN");

    public static void main(String[] args) {
        Twilio.init(ACCOUNT_SID, AUTH_TOKEN);
        Call call = Call.creator(
                new com.twilio.type.PhoneNumber("+14155551212"),
                new com.twilio.type.PhoneNumber("+14155551212"),
                URI.create("http://demo.twilio.com/docs/classic.mp3"))
            .create();
    
        System.out.println(call.getSid());
    }
}

package com.plivo.api.samples.call;

import java.io.IOException;
import java.util.Collections;

import com.plivo.api.Plivo;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.call.Call;
import com.plivo.api.models.call.CallCreateResponse;

class CallCreate {
public static final String AUTH_ID = System.getenv("PLIVO_AUTH_ID");
public static final String AUTH_TOKEN = System.getenv("PLIVO_AUTH_TOKEN");
    public static void main(String [] args) {
        Plivo.init(AUTH_ID,AUTH_TOKEN);
        try {
            CallCreateResponse response = Call.creator("+14151234567", 
            Collections.singletonList("+15671234567"), 
            "https://s3.amazonaws.com/static.plivo.com/answer.xml")
                .answerMethod("GET")
                .create();

            System.out.println(response);
        } catch (PlivoRestException | IOException e) {
            e.printStackTrace();
        }
    }
}

Alternatively, you can implement the same functionality using one of our PHLO templates. For example, if you want to make an outbound call, your PHLO would be this:

How to receive an incoming call

You can migrate an application for receiving and handling an incoming call from Twilio to Plivo just as seamlessly, as in this example:

Twilio Plivo

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.twilio.twiml.voice.Say;
import com.twilio.twiml.TwiMLException;
import com.twilio.twiml.VoiceResponse;

@SuppressWarnings("serial")
@WebServlet("/voice")
public class IncomingCallServlet extends
HttpServlet {
  protected void doPost(
     HttpServletRequest
     request, HttpServletResponse response)
      throws ServletException, IOException {
    VoiceResponse twiml = new
VoiceResponse.Builder()
        .say(new Say.Builder("Hello world!")
              .voice(Say.Voice.ALICE)
              .build())
        .build();
    response.setContentType("text/xml");

    try {
      response.getWriter().print(twiml.toXml());
    } catch (TwiMLException e) {
      e.printStackTrace();
    }



  }
}

import static spark.Spark.*;
import com.plivo.api.xml.Speak;
import com.plivo.api.xml.Response;

public class ReceiveCall {
    public static void main(String[] args) {
        post("/receive_call/", (request, 
        response) -> {
            response.type("application/xml");
            return new
Response().children(new Speak(
"Hello, you just received your first
call")).toXmlString();
        });
    }
}

Here again, you can implement the same functionality using one of our PHLO templates. Your PHLO would look like:

For more information about migrating your Voice applications to Plivo, check out our detailed use case guides, available for all seven programming languages and PHLO.

How to forward an incoming call

You can migrate an application for forwarding an incoming call from Twilio to Plivo just as seamlessly, as in this example:

Twilio Plivo

package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.twilio.twiml.voice.Dial;
import com.twilio.twiml.voice.Number;
import com.twilio.twiml.VoiceResponse;
import com.twilio.twiml.TwiMLException;
import java.io.IOException;
import java.util.Collections;

@SpringBootApplication
@RestController
public class TwilioVoiceApplication {

	public static void main(String[] args) {
		SpringApplication.run(TwilioVoiceApplication.class, args);
	}
	
	@GetMapping(value="/forward", produces={"application/xml"})
public String forwardCall() throws TwiMLException {
		Number number = new Number.Builder("415-123-4567").build();
        Dial dial = new Dial.Builder().number(number).build();
        VoiceResponse response = new VoiceResponse.Builder().dial(dial).build();
		  return response..toXml();
	}

}

package com.example.demo;
import com.plivo.api.Plivo;
import com.plivo.api.exceptions.PlivoRestException;
import com.plivo.api.models.call.Call;
import com.plivo.api.models.call.CallCreateResponse;
import com.plivo.api.xml.Dial;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.plivo.api.exceptions.PlivoXmlException;
import com.plivo.api.xml.Response;
import com.plivo.api.xml.Speak;
import com.plivo.api.xml.Number;
import java.io.IOException;
import java.util.Collections;

@SpringBootApplication
@RestController
public class PlivoVoiceApplication {

	public static void main(String[] args) {
		SpringApplication.run(PlivoVoiceApplication.class, args);
	}
	
	@GetMapping(value="/forward", produces={"application/xml"})
public String forwardCall(@RequestParam("From") String fromNumber) 
throws PlivoXmlException {
		Response res = new Response()
				.children(
						new Dial()
								.callerId(fromNumber)
								.children(
										new Number("+15671234567")
								)
				);
		return res.toXmlString();
	}

}

Here again, you can implement the same functionality using one of our PHLO templates. Your PHLO would look like:

For more information about migrating your Voice applications to Plivo, check out our detailed use case guides, available for all seven programming languages and PHLO.

More use cases

You can migrate your applications serving other use cases too.

Simple and reliable

And that’s all there is to migrate your Java voice app from Twilio to Plivo. Our simple APIs work in tandem with our Premium Communications Network. See for yourself — sign up for a free trial account.