How to Build an SMS Stock Notification App with Go and Twilio

Time to read: 5 minutes

January 24, 2025

Written by

David Fagbuyiro

Contributor

Reviewed by

Matthew Setter

Twilion

How to Build an SMS Stock Notification App with Go and Twilio

Staying informed about the latest stock market movements is crucial for investors and traders alike. With the rise of mobile technology, receiving real-time stock price updates via SMS can be a game-changer.

This tutorial will guide you through creating a powerful SMS-based stock price update system using Go and Twilio. By the end of this tutorial, you'll have a working application that sends real-time stock price notifications directly to your mobile device, allowing you to make informed investment decisions on the go.

Prerequisites

Before we begin, ensure you have the following:

Go version 1.22 or above
ngrok and a free ngrok account; this is needed to tunnel the application to expose the locally running Go application to the internet, allowing Twilio's SMS webhook to send real-time stock price updates
A Twilio account (either free or paid). If you are new to Twilio, click here to create a free account
An Alpha Vantage account; I recommend requiring the Alpha Vantage service, as you use it throughout the tutorial
Basic knowledge of Go
A mobile phone that can send SMS

Set up the Project

To continue with this tutorial, you have to start by:

Creating a new project directory and Go module
Retrieving the Alpha Vantage API key and Twilio credentials and storing them in .env at the root of the project
Installing the needed Go packages such as gorilla/mux, GoDotEnv, and twilio-go
Creating an endpoint in the app to take incoming SMS, check the given stock prices, and respond by SMS to the given phone with the Twilio API
Finally, you will open ngrok to open your local server to the world for testing, set up the webhook on Twilio, and live-notify prices of stocks through SMS

Create the Project directory

First, we'll create a new directory for our project, navigate into it, and initialize a new Go module.

mkdir twilio-sms-handler
cd twilio-sms-handler
go mod init twilio-sms-handler

Create the required environment variables

To keep your API keys and other sensitive information secure, you should use environment variables stored in a .env file. Now, create a .env file in the root of your project and add the following keys:

ALPHA_VANTAGE_API_KEY=<your_alpha_vantage_api_key>
TWILIO_ACCOUNT_SID=<your_twilio_account_sid>
TWILIO_AUTH_TOKEN=<your_twilio_auth_token>
TWILIO_PHONE_NUMBER=<your_twilio_phone_number>

The ALPHA_VANTAGE_API_KEY is required to access financial data via Alpha Vantage. The TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, and TWILIO_PHONE_NUMBER are credentials needed to interact with the Twilio API.

By replacing the placeholders (<your_alpha_vantage_api_key>, <your_twilio_account_sid>, <your_twilio_auth_token>, and <your_twilio_phone_number>) with actual values which you'll retrieve shortly, the application can authenticate and utilize the functionalities of both services.

Retrieve your Alpha Vantage API key

Alpha Vantage provides a comprehensive API for fetching stock data. You'll need to sign up for an API key here by entering your email address and pressing the GET FREE API KEY button.

Then, copy the API key and place it in place of <your_alpha_vantage_api_key> in .env.

Retrieve your Twilio Access Token

Next, log in to your Twilio Console to retrieve your Account SID, Auth Token, and Twilio phone number, as you can see in the screenshot below

Then, use them to replace <your_twilio_account_sid>, <your_twilio_auth_token>, and <your_twilio_phone_number>, respectively, in .env.

Install the necessary packages

We'll next need several packages to build our application. These are:

Gorilla Mux: This package is a request router and dispatcher that matches incoming HTTP requests to their respective handlers. "Mux" is short for "HTTP request multiplexer," It supports matching based on URL host, path, schemes, headers, query values, and HTTP methods, and allows variables with optional regular expressions.
GoDotEnv: This package simplifies managing environment variables. The package loads the required environment variables from .env into the Go application, aiding in configuration management.
twilio-go: The package is a client library for interfacing with the Twilio API, enabling functionality such as sending messages and making calls.

To install the above packages, run the following command.

go get -u github.com/gorilla/mux github.com/joho/godotenv github.com/kevinburke/twilio-go

Create the application's logic

Next, let’s create an endpoint to handle incoming SMS messages. This endpoint will receive the stock symbol, fetch the stock price, and send a response back to the user.

Create a file named main.go and add the following code:

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    "strings"
    "github.com/gorilla/mux"
    "github.com/joho/godotenv"
    "github.com/kevinburke/twilio-go"
)

type AlphaVantageResponse struct {
    TimeSeries map[string]map[string]string `json:"Time Series (5min)"`
}

func getStockPrice(symbol string, apiKey string) (string, error) {
    url := fmt.Sprintf("https://www.alphavantage.co/query?function=TIME_SERIES_INTRADAY&symbol=%s&interval=5min&apikey=%s", symbol, apiKey)
    resp, err := http.Get(url)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return "", err
    }

    var data AlphaVantageResponse
    if err := json.Unmarshal(body, &data); err != nil {
        return "", err
    }
    if len(data.TimeSeries) == 0 {
        return "", fmt.Errorf("no data available for symbol %s", symbol)
    }
    for _, v := range data.TimeSeries {
        return v["1. open"], nil
    }

    return "", fmt.Errorf("no data available for symbol %s", symbol)
}

func smsHandler(w http.ResponseWriter, r *http.Request) {
    from := r.PostFormValue("From")
    body := strings.TrimSpace(strings.ToUpper(r.PostFormValue("Body")))
    log.Printf("Received message from %s: %s", from, body)
    apiKey := os.Getenv("ALPHA_VANTAGE_API_KEY")
    price, err := getStockPrice(body, apiKey)
    twilioClient := twilio.NewClient(os.Getenv("TWILIO_ACCOUNT_SID"), os.Getenv("TWILIO_AUTH_TOKEN"), nil)

    if err != nil {
        log.Printf("Error fetching stock price: %s", err.Error())
        _, err := twilioClient.Messages.SendMessage(os.Getenv("TWILIO_PHONE_NUMBER"), from, "Sorry, there was an error fetching the stock price.", nil)
        if err != nil {
            log.Printf("Error sending message: %s", err.Error())
        }
        return
    }

    responseMessage := fmt.Sprintf("The current price of %s is $%s.", body, price)
    _, err = twilioClient.Messages.SendMessage(os.Getenv("TWILIO_PHONE_NUMBER"), from, responseMessage, nil)
    if err != nil {
        log.Printf("Error sending message: %s", err.Error())
    } else {
        log.Printf("Message sent to %s", from)
    }
}

func main() {
    if err := godotenv.Load(); err != nil {
        log.Fatal("Error loading .env file")
    }
    r := mux.NewRouter()
    r.HandleFunc("/sms", smsHandler).Methods("POST")
    http.Handle("/", r)
    
    port := ":3000"
    log.Printf("Server is running on port %s", port)
    log.Fatal(http.ListenAndServe(port, nil))
}

The Go code above uses gorilla/mux for routing, GoDotEnv to load environment variables, and the twilio-go client for sending SMS messages.

The getStockPrice() function makes an API call to Alpha Vantage to fetch the latest stock price for the given stock symbol. The "/sms" endpoint is a Twilio webhook that handles incoming SMS messages, extracting the stock symbol from the message body and using the getStockPrice() function to fetch the stock price. The stock price is then sent back to the user via Twilio's messaging API. The server listens on port 3000 and logs relevant information and errors for debugging purposes.

Start the application

Now, start the application by running the command below in your terminal:

go run main.go

Your application should now be running on port 3000.

Tunnel the application

To configure the Twilio SMS webhook, you need to make the application accessible online. Do this using ngrok by running the command below in a new terminal tab or session.

ngrok http 3000

Next, copy the generated forwarding address as shown in the screenshot below.

Configure the Twilio SMS webhook

To configure Twilio to send incoming SMS messages to your application, follow these steps:

Log in to your Twilio Console
Navigate to Phone Numbers > Manage > Active numbers and select the phone number you want to use
In the Messaging section, set A message comes in to "Webhook", the URL field next to it to the ngrok Forwarding URL, and append "/sms" to the end of the URL, e.g., https://d2c6-102-88-71-831.ngrok-free.app/sms
Click Save configuration to save the changes

Test the application

To test the application, open the SMS app on your phone and send your stock quote from the phone number you used to register for Twilio to your Twilio-generated phone number. After sending the message, you will receive the current stock price for that quote as shown below.

The image output displays IBM's current price at $192.130.

Retrieve the stock price

Below is an image showing the current stock price of different stocks using the newly generated API.

Make sure you type the stock symbol in all caps to avoid error messages from fetching the stock price.

That's how to build an SMS stock price update app with Go and Twilio

In this tutorial, we developed a Go application to retrieve stock prices and send updates via SMS using Twilio. We covered setting up the environment, fetching stock prices, sending SMS, and enhancing the script with additional features. By following these steps, you can automate stock price notifications and tailor the program to suit your needs.

David Fagbuyiro is a software engineer, technical writer, and experienced technical content editor who is passionate about extending his knowledge to developers through technical writing. You can find him on LinkedIn.

Stock icon in the post's main image was created by ultimatearm on Flaticon.