Nexmo Server SDK For Go

This SDK has moved! It is now vonage-go-sdk, located at vonage/vonage-go-sdk. New features will be released under vonage/vonage-go-sdk, so to take advantage of those please make sure to switch as soon as possible so you don't miss out!

For users of older versions: if tracking master gives you a surprise on update, pin to v0.8.1, this is the release from before the refactor and the move to vonage.

If you don't already know Nexmo: We make telephony APIs. If you need to make a call, check a phone number, or send an SMS then you are in the right place! If you don't have a Nexmo yet, you can sign up for a Nexmo account and get some free credit to get you started.

Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.

Installation

Find current and past releases on the releases page.

Recommended process (Go 1.13+)

Import the package and use it:

import ("github.com/nexmo-community/nexmo-go")

Older versions of Go (<= 1.12)

To install the package, use go get:

go get github.com/nexmo-community/nexmo-go

Or import the package into your project and then do go get ..

Usage

Here are some simple examples to get you started. If there's anything else you'd like to see here, please open an issue and let us know! Be aware that this library is still at an alpha stage so things may change between versions.

Number Insight

package main

import (
	"fmt"
	"net/http"

	"log"

	"github.com/nexmo-community/nexmo-go"
)

func main() {
	auth := nexmo.NewAuthSet()
	auth.SetAPISecret(API_KEY, API_SECRET)
	client := nexmo.New(http.DefaultClient, auth)
	insight, _, err := client.Insight.GetBasicInsight(nexmo.BasicInsightRequest{
		Number: PHONE_NUMBER,
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Country Name:", insight.CountryName)
	fmt.Println("Local Formatting:", insight.NationalFormatNumber)
	fmt.Println("International Formatting:", insight.InternationalFormatNumber)
}

Sending SMS

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/nexmo-community/nexmo-go"
)

func main() {
	auth := nexmo.NewAuthSet()
	auth.SetAPISecret(API_KEY, API_SECRET)

	client := nexmo.NewClient(http.DefaultClient, auth)
	smsReq := nexmo.SendSMSRequest {
	    From: FROM_NUMBER,
	    To: TO_NUMBER,
	    Text: "This message comes to you from Nexmo via Golang",
    }

	callR, _, err := client.SMS.SendSMS(smsReq)

	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Status:", callR.Messages[0].Status)
}

Receiving SMS

package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {

	http.HandleFunc("/webhooks/inbound-sms", func(w http.ResponseWriter, r *http.Request) {
		params := r.URL.Query()
		fmt.Println("SMS from " + params["msisdn"][0] + ": " + string(params["text"][0]))
	})

	http.ListenAndServe(":8080", nil)
}

Starting a Verify Request

    package main

    import (
        "fmt"
        "github.com/nexmo-community/nexmo-go"
        "log"
        "net/http"
    )

    func verify_start() {
        auth := nexmo.NewAuthSet()
        auth.SetAPISecret(API_KEY, API_SECRET)
        client := nexmo.NewClient(http.DefaultClient, auth)
        verification, _, err := client.Verify.Start(nexmo.StartVerificationRequest{
            Number: PHONE_NUMBER,
            Brand:  "Golang Docs",
        })
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("Request ID:", verification.RequestID)
    }

    func main() {
        verify_start()
    }

Confirming a Verify Code

    package main

    import (
        "fmt"
        "github.com/nexmo-community/nexmo-go"
        "log"
        "net/http"
    )

    func verify_check() {
        auth := nexmo.NewAuthSet()
        auth.SetAPISecret(API_KEY, API_SECRET)
        client := nexmo.NewClient(http.DefaultClient, auth)
        response, _, err := client.Verify.Check(nexmo.CheckVerificationRequest{
            RequestID: REQUEST_ID,
            Code:      CODE,
        })
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("Status:", response.Status)
        fmt.Println("Cost:", response.Price)
    }

    func main() {
        verify_check()
    }

Make a Phone Call

The Voice API uses applications and private keys for authentication. To use this snippet you will need a Nexmo number (for the "from" field), and an application with an ID and a private key. You can learn more about creating applications on the Developer Portal.

	// get the private key ready, assume file name private.key
	file, file_err := os.Open("private.key")
	if file_err != nil {
		log.Fatal(file_err)
	}
	defer file.Close()

	key, _ := ioutil.ReadAll(file)

	auth := nexmo.NewAuthSet()
	auth.SetApplicationAuth(APPLICATION_ID, key)
	client := nexmo.NewClient(http.DefaultClient, auth)

	to := make([]interface{}, 1)
	to[0] = nexmo.PhoneCallEndpoint{
		Type:   "phone",
		Number: TO_NUMBER,
	}

	response, _, err := client.Call.CreateCall(nexmo.CreateCallRequest{
		From:      nexmo.PhoneCallEndpoint{"phone", NEXMO_NUMBER, ""},
		To:        to,
		AnswerURL: []string{ANSWER_URL},
		EventURL:  []string{EVENT_URL},
	})

	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Status:", response.Status)

Getting Help

We love to hear from you so if you have questions, comments or find a bug in the project, let us know! You can either:

• Open an issue on this repository
• Tweet at us! We're @NexmoDev on Twitter
• Or join the Nexmo Community Slack

Further Reading

• Check out the Developer Documentation at https://developer.nexmo.com - you'll find the API references for all the APIs there as well
• The documentation for the library: https://godoc.org/github.com/nexmo-community/nexmo-go