Record Calls Using Go

Overview

This guide shows how to initiating call recordings for outbound API calls, Dial XML-connected calls, and conference calls. You can record inbound calls to a Plivo number too when the application associated with the number returns an XML document with a Dial and a Record element.

Prerequisites

To get started, you need a Plivo account — sign up with your work email address if you don’t have one already. You must have a voice-enabled Plivo phone number to receive incoming calls; you can rent numbers from the Numbers page of the Plivo console, or by using the Numbers API. If this is your first time using Plivo APIs, follow our instructions to set up a Go development environment and a web server and safely expose that server to the internet.

Record a complete outbound call using XML

You can record a complete call session using the Record XML element in conjunction with a Dial element response that’s returned by an answer URL. Recording a complete call is useful in applications such as virtual voicemail boxes and automated speech surveys.

The XML might look like this:

<Response>
 <Record action="https://<yourdomain>.com/get_recording/" startOnDialAnswer="true" redirect="false" maxLength="3600" />
 <Dial>
  <Number>12025551234</Number>
 </Dial>
</Response>

When the number specified in the Dial XML element answers the call, Plivo records the complete call session. Recording details are sent to the action URL as soon as the recording starts. You can use the attributes available in the Record XML element to control the recording behavior.

Create a file called record_call.go and paste into it this code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main
import "github.com/plivo/plivo-go/v7/xml"
func main() {
  response: = xml.ResponseElement {
    Contents: [] interface {} {
   new(xml.RecordElement).
   SetAction("https://<yourdomain>.com/get_recording/").
   SetRedirect(false).
   SetStartOnDialAnswer(true),

     new(xml.DialElement).
   SetContents([] interface {} {
     new(xml.NumberElement).
     SetContents("<phone_number>"),
   }),
 },
}
print(response.String())
}

Replace the phone number placeholder with an actual phone number (for example, 12025551234).

Record a complete conference call using XML

You can record a complete conference call initiated using a Conference XML element by using an XML response like this:

<Response>
  <Conference callbackUrl="https://<yourdomain>.com/confevents/" callbackMethod="POST" record="true" recordFileFormat="wav">My Room</Conference>
</Response>

Plivo will record the complete audio of a conference call connected via this XML document. Recording details are sent to the action URL and callback URL as soon as the recording starts. The parameter ConferenceAction=record is also sent to the callback URL when the recording starts.

Create a file called record_call.go and paste into it this code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main
import "github.com/plivo/plivo-go/v7/xml"
func main() {
  response: = xml.ResponseElement {
    Contents: [] interface {} {
      new(xml.SpeakElement).
      AddSpeak("You will now be placed into the conference"), 
        new(xml.ConferenceElement).
      SetRecord(true).
      SetCallbackMethod("POST").
      SetCallbackUrl("https://<yourdomain>.com/confevents/").
      SetWaitSound("https://<yourdomain>.com/waitmusic/").
      SetContents("<conference_room_name> "),
    },
  }
  print(response.String())
}

Start and stop call recording using APIs

You can start and stop voice recordings for outbound API calls, Dial XML-connected calls, and conference calls using the Record API and Record Conference API.

Record API

To start recording using the Record API, you must use the CallUUID of the particular call that you want to record.

Retrieve a CallUUID

You can get the CallUUID of a call connected via the Outbound API and Dial XML from any of these arguments:

ring_url: Plivo sends a webhook callback to the ring URL used in the call API request as soon as the destination number starts ringing.
answer_url: Plivo sends a webhook callback to the answer URL when the destination number answers the call.
fallback_url: If you define the fallback URL argument in the API request or the application attached to the Plivo number, and if the application server defined in the answer URL is unavailable, then Plivo will try to retrieve the XML document from the fallback URL to process the call. At that time Plivo will send a webhook callback to the fallback URL.
callback_url: If you use the callbackUrl parameter in the Dial XML, Plivo will send a callback to the web server configured in callback URL when the number specified in the Dial XML element answers the call.

Start recording

Once you have the CallUUID of the call you want to record, you can call the record API and specify the CallUUID in the payload.

For example, if you want to record an outbound API call, you can use the code below to record the call once the destination number answers the call. The recording will stop automatically once the call is completed.

Create a file called record_call.go and paste into it this code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main
import (
  "fmt"
  "github.com/go-martini/martini"
  "github.com/plivo/plivo-go/v7/xml"
  "github.com/plivo/plivo-go/v7"
  "net/http"
)
func main() {
  m: = martini.Classic()
  m.Post("/record/", func(w http.ResponseWriter, r * http.Request) string {
    w.Header().Set("Content-Type", "application/xml")
    response: = xml.ResponseElement {
      Contents: [] interface {} {
        new(xml.GetInputElement).
        SetAction("https://<yourdomain>.com/record/action/").
        SetMethod("POST").
        SetDigitEndTimeout(5).
        SetInputType("dtmf").
        SetRedirect(true).
        SetContents([] interface {} {
          new(xml.SpeakElement).
          AddSpeak("Press 1 to record this call"),
        }),
      },
    }
    return response.String()
  })
  m.Post("/record/action/", func(w http.ResponseWriter, r * http.Request) string {
    digits: = r.FormValue("Digits")
    uuid: = r.FormValue("CallUUID")
    fmt.Printf("Digit received: %#v\n", digits)
    client,
    err: = plivo.NewClient("<auth_id>", "<auth_token>", & plivo.ClientOptions {})
    if err != nil {
      panic(err)
    }
    response,
    err: = client.Calls.Record(
      uuid,
      plivo.CallRecordParams {},
    )
    fmt.Printf("Response: %#v\n", response)
    return "ok"
  })
  m.Run()
}

Replace the auth placeholders with your authentication credentials from the Plivo console.

Stop recording

You can stop recording a call by using the CallUUID — see our API reference documentation.

Start and stop conference call recording using APIs

Record Conference API

To start recording conference calls using the Record Conference API, use the name of the conference you want to record. If you want to start recording a conference call once a participant has entered the conference room, you can use this code.

Create a file called record_call.go and paste into it this code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main
import "fmt"
import "github.com/plivo/plivo-go/v7"
func main() {
  err: = plivo.NewClient("<auth_id>", "<auth_token>", & plivo.ClientOptions {})
  if err != nil {
    panic(err)
  }
  response, err: = client.Conferences.Record(
    "<conference_room_name>",
    plivo.ConferenceRecordParams {},
  )
  if err != nil {
    panic(err)
  }
  fmt.Printf("Response: %#v\n", response)
}

Replace the auth placeholders with your authentication credentials from the Plivo console.

Stop recording

You can stop recording a conference call by using the conference name — see our API reference documentation.

Recording features

File formats: You can choose the recording file format (WAV or MP3) by using the file_format attribute for the Record API and Record Conference API, recordFileFormat for the Conference XML element, and fileFormat for the Record XML element.
Channels: Plivo makes mono recordings of conference calls and stereo recordings of regular calls.
Recording length: You can set the maximum duration of a recording by using arguments and attributes such as time_limit for the Record API and maxLength for the Record XML element.

Managing recordings

Fetching recording details: You can store and retrieve the recording details of the voice calls and conference calls using the HTTP callbacks received on the action and callback URLs. You can also fetch recording details from the Voice > Recordings page of the Plivo console.
Deleting recordings: You can delete a recording by using the Delete a Recording API and specifying a recording ID, which you can retrieve from the HTTP callback details stored in your database. You can also delete recordings from the Voice > Recordings page of the Plivo console.

Authentication for recordings

Recordings hosted on Plivo servers are accessible only via unique, hard to guess, long URLs that Plivo shares in recording callbacks and API responses. By default, we do not enforce authentication on GET recording media requests to allow for easy implementation of use cases that involve playing recordings on a web or mobile front end.

For enhanced security, we recommend enabling basic authentication for retrieving recording media assets in your Plivo account. You can enable Basic Auth for Recording URLs from the Voice > Other Settings page of the Plivo console.

Note: Only account admins (users with the role Admin) have the required privileges to update the recording authentication preference setting.

Rate this page

🥳 Thank you! It means a lot to us!