Contact sales Start for free
Contact sales Start for free

Avoid Sending SMS to Landlines with the Lookup v2 API and Go

Time to read:

October 07, 2026
Written by
Matthew Setter
Twilion

Avoid Sending SMS to Landlines with the Lookup v2 API and Go

SMS is one of the most effective ways of staying in touch with your customers. Why? Because:

  • SMS delivery isn't reliant on an internet connection
  • SMS are delivered almost instantly
  • SMS works on every mobile phone
  • SMS has an open rate of 98% (according to Forbes)

But, what if you have an application where users have provided landlines as well as mobile/cell numbers? How do you filter out landlines so that you don't receive intermittent errors and avoid paying for failed SMS.

Well, this tutorial will show you how to do so in Go using Twilio's Lookup v2 API.

Prerequisites

To follow along with this tutorial, you'll need the following:

  • A Twilio account (whether free or paid). Create one now if you don't have one already.
  • A Twilio phone number that can send SMS
  • Go 1.23 or above
  • A phone number that can receive SMS and a landline number (preferrably, one that belongs to you or a friend)
  • Your preferred text editor or IDE for writing Go

Build the Go application

The first thing to do is to create an empty Go project with module support. To do that, run the following commands wherever you store your go projects.

mkdir filter-landlines
cd filter-landlines
go mod init

Add the required libraries

Next, the project will need a few dependencies, these are:

To install them, run the following command. 

go get \
    github.com/twilio/twilio-go \
    github.com/joho/godotenv

Set the required environment variables

You need to set two environment variables which are required to make authenticated requests to Twilio's Lookup v2 API. To do that, in the project's top-level directory, create a new file named .env and paste the configuration below into the new file. 

TWILIO_ACCOUNT_SID=
TWILIO_AUTH_TOKEN=

Then, open the Twilio Console in your browser of choice, and copy the Account SID, Auth Token from the Workbench at the bottom of the page.

Dark mode dashboard displaying API credentials, quick actions, and navigation tabs for overview, debugger, and alarms.

Now, set the copied values as the values of TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN respectively, in .env.

Then, under Quick actions click Phone numbers, and copy an E.164-formatted phone number from the Phone Number column. Paste the phone number as the value of , and TWILIO_PHONE_NUMBER in .env.

Write the code

Now, it's time to write the code. Just one file. Create a new file named main.go in the project's top-level directory and in that file paste the code below. After that, replace <A MOBILE PHONE NUMBER> and <A LAND LINE NUMBER> with a mobile phone number and a land line, respectively. 

package main

import (
	"fmt"
	"iter"
	"log"
	"os"
	"github.com/joho/godotenv"
	"github.com/twilio/twilio-go"
	openapi "github.com/twilio/twilio-go/rest/api/v2010"
	lookups "github.com/twilio/twilio-go/rest/lookups/v2"
)

func main() {
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
	}

	client := twilio.NewRestClient()
	items := []string{"<A MOBILE PHONE NUMBER>", "<A LAND LINE NUMBER>"}
	for number := range filterLandlines(items, client) {
		err := sendSMS(client, number, os.Getenv("TWILIO_PHONE_NUMBER"), "Here is your SMS")
		if err != nil {
			fmt.Printf("Unable to send SMS to %s! Reason %s.\n", number, err.Error())
		} else {
			fmt.Printf("SMS sent successfully to %s.\n", number)
		}
	}
}

func filterLandlines(phoneNumbers []string, client *twilio.RestClient) iter.Seq[string] {
	return func(yield func(string) bool) {
		params := &lookups.FetchPhoneNumberParams{}
		params.SetFields("line_type_intelligence")
		for _, number := range phoneNumbers {
			resp, err := client.LookupsV2.FetchPhoneNumber(number, params)
			if err != nil {
				continue
			}

			if resp.LineTypeIntelligence.Type != "mobile" {
				fmt.Printf("%s is not a mobile/cell phone number.\n", number)
				continue
			}

			if !yield(number) {
				return
			}
		}
	}
}

func sendSMS(client *twilio.RestClient, recipient string, sender string, message string) error {
	params := &openapi.CreateMessageParams{}
	params.SetTo(recipient)
	params.SetFrom(sender)
	params.SetBody(message)
	_, err := client.Api.CreateMessage(params)
	if err != nil {
		return err
	}

	return nil
}

The code above defines three functions:

  • main(): is the application's entrypoint. It starts by loading the environment variables registered in .env, before initialising a new Twilio RestClient object, and an array of phone numbers to validate using Twilio's Lookup v2 API. Following that, the code iterates over the list of phone numbers returned from calling filterLandLines(), and attempts to send an SMS to each one by calling sendSMS(). The user is notified whether the SMS is sent successfully or not through text printed to the terminal.
  • filterLandLines(): uses a custom iterator to filter landlines from an array of phone numbers, returning an iterator of strings. As the iterator iterates over the array, it attempts to fetch the details of each phone number from Twilo's Lookup v2 API including Line Type Intelligence information. This information is necessary as it contains the phone number's type. If the phone number type is not set to "mobile", the number is not included in the returned iterator.
  • sendSMS(): is a small utility function that sends an SMS to the recipient with the message provided.

Test that the code works as expected

With the code written, let's see it in action, by running the following command in a new terminal tab or session.

go run main.go

You should see output similar to the following printed to the terminal. 

SMS sent successfully to +61123456789.
+15005550002 was identified as a landline.

That's how to avoid sending SMS to landlines in Go with Twilio's Lookup v2 API

Thanks to the power of Twilio's Lookup v2 API and Go's standard library, you don't need to write much code at all to filter landlines from a list of phone numbers. Make sure you use this functionality to avoid being charged for failed SMS, and create more robust Go applications that integrate with Twilio.

Matthew Setter is the PHP, Go, and Rust editor on the Twilio Voices team, and a developer in each of these languages. He’s also the author of Mezzio Essentials and Deploy with Docker Compose. You can find him at msetter[at]twilio.com, and on LinkedIn and GitHub.

Related Posts

Related Resources

A newspaper article

Twilio Docs

From APIs to SDKs to sample apps

API reference documentation, SDKs, helper libraries, quickstarts, and tutorials for your language and platform.
An Open book

Resource Center

The latest ebooks, industry reports, and webinars

Learn from customer engagement experts to improve your own communication.
User group reactions

Ahoy

Twilio's developer community hub

Best practices, code samples, and inspiration to build communications and digital engagement experiences.