Twilio API

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio provides bindings for Twilio's REST APIs.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio provides support for interacting with Twilio REST API This example shows the usage of twilio package. You can get your AccountSid and AuthToken on Account Dashboard page.

Package twilio provides bindings for Twilio's REST APIs.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio provides support for interacting with Twilio REST API

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio provides support for interacting with Twilio REST API This example shows the usage of twilio package. You can get your AccountSid and AuthToken on Account Dashboard page.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio provides support for interacting with Twilio REST API This example shows the usage of twilio package. You can get your AccountSid and AuthToken on Account Dashboard page.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package fox implements a simple client for the Twilio programmatic fax API. It implements all the functions associated with the "Faxes" endpoint, but to keep the library tight, does not facilitate, for example, E.164 phone number parsing and validation, or handling Twilio status callbacks. To get started, construct a new Client with your Twilio account SID and auth token: Optionally, you can also pass a pointer to a SendOptions object to NewClient to specify custom send options (to, for example, tell Twilio *not* to store fax media): The Get, List and Send methods on the returned Client are used to make the API calls as described by Twilio's API reference.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio provides support for interacting with Twilio REST API This example shows the usage of twilio package. You can get your AccountSid and AuthToken on Account Dashboard page.

Package twilio provides bindings for Twilio's REST APIs.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package utwil contains Go utilities for dealing with the Twilio API The most-used data structure is the Client, which stores credentials and has useful methods for interacing with Twilio. The current supported feature set includes the sending of Calls and Messages, retrieval of Calls and Messages, and the lookup of phone numbers. These actions will incur the appropriate costs on your Twilio account. Before go test, populate env vars TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_DEFAULT_TO, and TWILIO_DEFAULT_FROM. Start with: Commonly used actions have convenience functions: For more complicated requests, populate the respective XxxxxReq struct and call the SubmitXxxxx() method:

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio provides support for interacting with Twilio REST API This example shows the usage of twilio package. You can get your AccountSid and AuthToken on Account Dashboard page.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio is s small wrapper to be used with the Twilio API. Twilio lets you use standard web languages to build voice, VoIP and SMS applications via a web API. To use it, all that you need is to create a client: And to send a message just write:

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.

Package twilio simplifies interaction with the Twilio API. The twilio-go library should be your first choice for interacting with the Twilio API; it offers forward compatibility, very fine-grained control of API access, best-in-class control over how long to wait for requests to complete, and great debuggability when things go wrong. Get started by creating a Client: All of the Twilio resources are available as properties on the Client. Let's walk through some of the example use cases. Resources that can create new methods take a url.Values as an argument, and pass all arguments to the Twilio API. This method ensures forward compatibility; any new arguments that get invented can be added in client-side code. Call Get() with a particular sid. Call Update() with a particular sid and a url.Values. There are two flavors of interaction. First, if all you want is a single Page of resources, optionally with filters: To control the page size, set "PageSize": "N" in the url.Values{} field. Twilio defaults to returning 50 results per page if this is not set. Alternatively you can get a PageIterator and call Next() to repeatedly retrieve pages. Twilio Monitor subresources are available on the Client under the Monitor field, e.g. There are several custom types and helper functions designed to make your job easier. Where possible, we try to parse values from the Twilio API into a datatype that makes more sense. For example, we try to parse timestamps into Time values, durations into time.Duration, integer values into uints, even if the API returns them as strings, e.g. "3". All phone numbers have type PhoneNumber. By default these are E.164, but can be printed in Friendly()/Local() variations as well. Any times returned from the Twilio API are of type TwilioTime, which has two properties - Valid (a bool), and Time (a time.Time). Check Valid before using the related Time. There are constants for every Status in the API, for example StatusQueued, which has the value "queued". You can call Friendly() on any Status to get an uppercase version of the status, e.g.