<!-- Auto-generated from Telnyx OpenAPI specs. Do not edit. -->

Telnyx Sip - Go

Installation

bash
go get github.com/team-telnyx/telnyx-go

Setup

go
import (
  "context"
  "fmt"
  "os"

  "github.com/team-telnyx/telnyx-go"
  "github.com/team-telnyx/telnyx-go/option"
)

client := telnyx.NewClient(
  option.WithAPIKey(os.Getenv("TELNYX_API_KEY")),
)

All examples below assume client is already initialized as shown above.

Error Handling

All API calls can fail with network errors, rate limits (429), validation errors (422), or authentication errors (401). Always handle errors in production code:

go
import "errors"

result, err := client.Messages.Send(ctx, params)
if err != nil {
  var apiErr *telnyx.Error
  if errors.As(err, &apiErr) {
    switch apiErr.StatusCode {
    case 422:
      fmt.Println("Validation error — check required fields and formats")
    case 429:
      // Rate limited — wait and retry with exponential backoff
      fmt.Println("Rate limited, retrying...")
    default:
      fmt.Printf("API error %d: %s\n", apiErr.StatusCode, apiErr.Error())
    }
  } else {
    fmt.Println("Network error — check connectivity and retry")
  }
}

Common error codes: 401 invalid API key, 403 insufficient permissions, 404 resource not found, 422 validation error (check field formats), 429 rate limited (retry with exponential backoff).

Important Notes

• Pagination: Use ListAutoPaging() for automatic iteration: iter := client.Resource.ListAutoPaging(ctx, params); for iter.Next() { item := iter.Current() }.

List all Access IP Ranges

GET /access_ip_ranges

go
	page, err := client.AccessIPRanges.List(context.Background(), telnyx.AccessIPRangeListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: cidr_block (string), created_at (date-time), description (string), id (string), status (enum: pending, added), updated_at (date-time), user_id (string)

Create new Access IP Range

POST /access_ip_ranges — Required: cidr_block

Optional: description (string)

go
	accessIPRange, err := client.AccessIPRanges.New(context.Background(), telnyx.AccessIPRangeNewParams{
		CidrBlock: "203.0.113.0/24",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", accessIPRange.ID)

Returns: cidr_block (string), created_at (date-time), description (string), id (string), status (enum: pending, added), updated_at (date-time), user_id (string)

Delete access IP ranges

DELETE /access_ip_ranges/{access_ip_range_id}

go
	accessIPRange, err := client.AccessIPRanges.Delete(context.Background(), "access_ip_range_id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", accessIPRange.ID)

Returns: cidr_block (string), created_at (date-time), description (string), id (string), status (enum: pending, added), updated_at (date-time), user_id (string)

List connections

Returns a list of your connections irrespective of type.

GET /connections

go
	page, err := client.Connections.List(context.Background(), telnyx.ConnectionListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), connection_name (string), created_at (string), id (string), outbound_voice_profile_id (string), record_type (string), tags (arraystring]), updated_at (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri)

Retrieve a connection

Retrieves the high-level details of an existing connection. To retrieve specific authentication information, use the endpoint for the specific connection type.

GET /connections/{id}

go
	connection, err := client.Connections.Get(context.Background(), "id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", connection.Data)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), connection_name (string), created_at (string), id (string), outbound_voice_profile_id (string), record_type (string), tags (arraystring]), updated_at (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri)

List credential connections

Returns a list of your credential connections.

GET /credential_connections

go
	page, err := client.CredentialConnections.List(context.Background(), telnyx.CredentialConnectionListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), record_type (string), rtcp_settings (object), sip_uri_calling_preference (enum: disabled, unrestricted, internal), tags (arraystring]), updated_at (string), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Create a credential connection

Creates a credential connection.

POST /credential_connections — Required: user_name, password, connection_name

Optional: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), rtcp_settings (object), sip_uri_calling_preference (enum: disabled, unrestricted, internal), tags (arraystring]), webhook_api_version (enum: 1, 2, texml), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

go
	credentialConnection, err := client.CredentialConnections.New(context.Background(), telnyx.CredentialConnectionNewParams{
		ConnectionName: "my name",
		Password:       "my123secure456password789",
		UserName:       "myusername123",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", credentialConnection.Data)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), record_type (string), rtcp_settings (object), sip_uri_calling_preference (enum: disabled, unrestricted, internal), tags (arraystring]), updated_at (string), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Retrieve a credential connection

Retrieves the details of an existing credential connection.

GET /credential_connections/{id}

go
	credentialConnection, err := client.CredentialConnections.Get(context.Background(), "id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", credentialConnection.Data)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), record_type (string), rtcp_settings (object), sip_uri_calling_preference (enum: disabled, unrestricted, internal), tags (arraystring]), updated_at (string), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Update a credential connection

Updates settings of an existing credential connection.

PATCH /credential_connections/{id}

Optional: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), rtcp_settings (object), sip_uri_calling_preference (enum: disabled, unrestricted, internal), tags (arraystring]), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

go
	credentialConnection, err := client.CredentialConnections.Update(
		context.Background(),
		"id",
		telnyx.CredentialConnectionUpdateParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", credentialConnection.Data)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), record_type (string), rtcp_settings (object), sip_uri_calling_preference (enum: disabled, unrestricted, internal), tags (arraystring]), updated_at (string), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Delete a credential connection

Deletes an existing credential connection.

DELETE /credential_connections/{id}

go
	credentialConnection, err := client.CredentialConnections.Delete(context.Background(), "id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", credentialConnection.Data)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), record_type (string), rtcp_settings (object), sip_uri_calling_preference (enum: disabled, unrestricted, internal), tags (arraystring]), updated_at (string), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Check a Credential Connection Registration Status

Checks the registration_status for a credential connection, (registration_status) as well as the timestamp for the last SIP registration event (registration_status_updated_at)

POST /credential_connections/{id}/actions/check_registration_status

go
	response, err := client.CredentialConnections.Actions.CheckRegistrationStatus(context.Background(), "id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: ip_address (string), last_registration (string), port (integer), record_type (string), sip_username (string), status (enum: Not Applicable, Not Registered, Failed, Expired, Registered, Unregistered), transport (string), user_agent (string)

List FQDN connections

Returns a list of your FQDN connections.

GET /fqdn_connections

go
	page, err := client.FqdnConnections.List(context.Background(), telnyx.FqdnConnectionListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: active (boolean), adjust_dtmf_timestamp (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_enabled (boolean), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), ignore_dtmf_duration (boolean), ignore_mark_bit (boolean), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), microsoft_teams_sbc (boolean), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), record_type (string), rtcp_settings (object), rtp_pass_codecs_on_stream_change (boolean), send_normalized_timestamps (boolean), tags (arraystring]), third_party_control_enabled (boolean), transport_protocol (enum: UDP, TCP, TLS), txt_name (string), txt_ttl (integer), txt_value (string), updated_at (string), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Create an FQDN connection

Creates a FQDN connection.

POST /fqdn_connections — Required: connection_name

Optional: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), microsoft_teams_sbc (boolean), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), rtcp_settings (object), tags (arraystring]), transport_protocol (enum: UDP, TCP, TLS), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

go
	fqdnConnection, err := client.FqdnConnections.New(context.Background(), telnyx.FqdnConnectionNewParams{
		ConnectionName: "my-resource",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", fqdnConnection.Data)

Returns: active (boolean), adjust_dtmf_timestamp (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_enabled (boolean), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), ignore_dtmf_duration (boolean), ignore_mark_bit (boolean), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), microsoft_teams_sbc (boolean), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), record_type (string), rtcp_settings (object), rtp_pass_codecs_on_stream_change (boolean), send_normalized_timestamps (boolean), tags (arraystring]), third_party_control_enabled (boolean), transport_protocol (enum: UDP, TCP, TLS), txt_name (string), txt_ttl (integer), txt_value (string), updated_at (string), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Retrieve an FQDN connection

Retrieves the details of an existing FQDN connection.

GET /fqdn_connections/{id}

go
	fqdnConnection, err := client.FqdnConnections.Get(context.Background(), "1293384261075731499")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", fqdnConnection.Data)

Returns: active (boolean), adjust_dtmf_timestamp (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_enabled (boolean), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), ignore_dtmf_duration (boolean), ignore_mark_bit (boolean), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), microsoft_teams_sbc (boolean), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), record_type (string), rtcp_settings (object), rtp_pass_codecs_on_stream_change (boolean), send_normalized_timestamps (boolean), tags (arraystring]), third_party_control_enabled (boolean), transport_protocol (enum: UDP, TCP, TLS), txt_name (string), txt_ttl (integer), txt_value (string), updated_at (string), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Update an FQDN connection

Updates settings of an existing FQDN connection.

PATCH /fqdn_connections/{id}

Optional: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), rtcp_settings (object), tags (arraystring]), transport_protocol (enum: UDP, TCP, TLS), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

go
	fqdnConnection, err := client.FqdnConnections.Update(
		context.Background(),
		"1293384261075731499",
		telnyx.FqdnConnectionUpdateParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", fqdnConnection.Data)

Returns: active (boolean), adjust_dtmf_timestamp (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_enabled (boolean), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), ignore_dtmf_duration (boolean), ignore_mark_bit (boolean), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), microsoft_teams_sbc (boolean), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), record_type (string), rtcp_settings (object), rtp_pass_codecs_on_stream_change (boolean), send_normalized_timestamps (boolean), tags (arraystring]), third_party_control_enabled (boolean), transport_protocol (enum: UDP, TCP, TLS), txt_name (string), txt_ttl (integer), txt_value (string), updated_at (string), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Delete an FQDN connection

Deletes an FQDN connection.

DELETE /fqdn_connections/{id}

go
	fqdnConnection, err := client.FqdnConnections.Delete(context.Background(), "1293384261075731499")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", fqdnConnection.Data)

Returns: active (boolean), adjust_dtmf_timestamp (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_enabled (boolean), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), ignore_dtmf_duration (boolean), ignore_mark_bit (boolean), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), microsoft_teams_sbc (boolean), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), password (string), record_type (string), rtcp_settings (object), rtp_pass_codecs_on_stream_change (boolean), send_normalized_timestamps (boolean), tags (arraystring]), third_party_control_enabled (boolean), transport_protocol (enum: UDP, TCP, TLS), txt_name (string), txt_ttl (integer), txt_value (string), updated_at (string), user_name (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

List FQDNs

Get all FQDNs belonging to the user that match the given filters.

GET /fqdns

go
	page, err := client.Fqdns.List(context.Background(), telnyx.FqdnListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: connection_id (string), created_at (string), dns_record_type (string), fqdn (string), id (string), port (integer), record_type (string), updated_at (string)

Create an FQDN

Create a new FQDN object.

POST /fqdns — Required: fqdn, dns_record_type, connection_id

Optional: port (integer | null)

go
	fqdn, err := client.Fqdns.New(context.Background(), telnyx.FqdnNewParams{
		ConnectionID:  "1516447646313612565",
		DNSRecordType: "a",
		Fqdn:          "example.com",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", fqdn.Data)

Returns: connection_id (string), created_at (string), dns_record_type (string), fqdn (string), id (string), port (integer), record_type (string), updated_at (string)

Retrieve an FQDN

Return the details regarding a specific FQDN.

GET /fqdns/{id}

go
	fqdn, err := client.Fqdns.Get(context.Background(), "1517907029795014409")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", fqdn.Data)

Returns: connection_id (string), created_at (string), dns_record_type (string), fqdn (string), id (string), port (integer), record_type (string), updated_at (string)

Update an FQDN

Update the details of a specific FQDN.

PATCH /fqdns/{id}

Optional: connection_id (string), dns_record_type (string), fqdn (string), port (integer | null)

go
	fqdn, err := client.Fqdns.Update(
		context.Background(),
		"1517907029795014409",
		telnyx.FqdnUpdateParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", fqdn.Data)

Returns: connection_id (string), created_at (string), dns_record_type (string), fqdn (string), id (string), port (integer), record_type (string), updated_at (string)

Delete an FQDN

Delete an FQDN.

DELETE /fqdns/{id}

go
	fqdn, err := client.Fqdns.Delete(context.Background(), "1517907029795014409")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", fqdn.Data)

Returns: connection_id (string), created_at (string), dns_record_type (string), fqdn (string), id (string), port (integer), record_type (string), updated_at (string)

List Ip connections

Returns a list of your IP connections.

GET /ip_connections

go
	page, err := client.IPConnections.List(context.Background(), telnyx.IPConnectionListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), record_type (string), rtcp_settings (object), tags (arraystring]), transport_protocol (enum: UDP, TCP, TLS), updated_at (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Create an Ip connection

Creates an IP connection.

POST /ip_connections

Optional: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), rtcp_settings (object), tags (arraystring]), transport_protocol (enum: UDP, TCP, TLS), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

go
	ipConnection, err := client.IPConnections.New(context.Background(), telnyx.IPConnectionNewParams{
		ConnectionName: "my-ip-connection",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", ipConnection.Data)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), record_type (string), rtcp_settings (object), tags (arraystring]), transport_protocol (enum: UDP, TCP, TLS), updated_at (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Retrieve an Ip connection

Retrieves the details of an existing ip connection.

GET /ip_connections/{id}

go
	ipConnection, err := client.IPConnections.Get(context.Background(), "id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", ipConnection.Data)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), record_type (string), rtcp_settings (object), tags (arraystring]), transport_protocol (enum: UDP, TCP, TLS), updated_at (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Update an Ip connection

Updates settings of an existing IP connection.

PATCH /ip_connections/{id}

Optional: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), rtcp_settings (object), tags (arraystring]), transport_protocol (enum: UDP, TCP, TLS), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

go
	ipConnection, err := client.IPConnections.Update(
		context.Background(),
		"id",
		telnyx.IPConnectionUpdateParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", ipConnection.Data)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), record_type (string), rtcp_settings (object), tags (arraystring]), transport_protocol (enum: UDP, TCP, TLS), updated_at (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Delete an Ip connection

Deletes an existing IP connection.

DELETE /ip_connections/{id}

go
	ipConnection, err := client.IPConnections.Delete(context.Background(), "id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", ipConnection.Data)

Returns: active (boolean), anchorsite_override (enum: Latency, Chicago, IL, Ashburn, VA, San Jose, CA, Sydney, Australia, Amsterdam, Netherlands, London, UK, Toronto, Canada, Vancouver, Canada, Frankfurt, Germany), android_push_credential_id (string | null), call_cost_in_webhooks (boolean), connection_name (string), created_at (string), default_on_hold_comfort_noise_enabled (boolean), dtmf_type (enum: RFC 2833, Inband, SIP INFO), encode_contact_header_enabled (boolean), encrypted_media (enum: SRTP, None), id (string), inbound (object), ios_push_credential_id (string | null), jitter_buffer (object), noise_suppression (enum: inbound, outbound, both, disabled), noise_suppression_details (object), onnet_t38_passthrough_enabled (boolean), outbound (object), record_type (string), rtcp_settings (object), tags (arraystring]), transport_protocol (enum: UDP, TCP, TLS), updated_at (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

List Ips

Get all IPs belonging to the user that match the given filters.

GET /ips

go
	page, err := client.IPs.List(context.Background(), telnyx.IPListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: connection_id (string), created_at (string), id (string), ip_address (string), port (integer), record_type (string), updated_at (string)

Create an Ip

Create a new IP object.

POST /ips — Required: ip_address

Optional: connection_id (string), port (integer)

go
	ip, err := client.IPs.New(context.Background(), telnyx.IPNewParams{
		IPAddress: "192.168.0.0",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", ip.Data)

Returns: connection_id (string), created_at (string), id (string), ip_address (string), port (integer), record_type (string), updated_at (string)

Retrieve an Ip

Return the details regarding a specific IP.

GET /ips/{id}

go
	ip, err := client.IPs.Get(context.Background(), "6a09cdc3-8948-47f0-aa62-74ac943d6c58")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", ip.Data)

Returns: connection_id (string), created_at (string), id (string), ip_address (string), port (integer), record_type (string), updated_at (string)

Update an Ip

Update the details of a specific IP.

PATCH /ips/{id} — Required: ip_address

Optional: connection_id (string), port (integer)

go
	ip, err := client.IPs.Update(
		context.Background(),
		"6a09cdc3-8948-47f0-aa62-74ac943d6c58",
		telnyx.IPUpdateParams{
			IPAddress: "192.168.0.0",
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", ip.Data)

Returns: connection_id (string), created_at (string), id (string), ip_address (string), port (integer), record_type (string), updated_at (string)

Delete an Ip

Delete an IP.

DELETE /ips/{id}

go
	ip, err := client.IPs.Delete(context.Background(), "6a09cdc3-8948-47f0-aa62-74ac943d6c58")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", ip.Data)

Returns: connection_id (string), created_at (string), id (string), ip_address (string), port (integer), record_type (string), updated_at (string)

Get all outbound voice profiles

Get all outbound voice profiles belonging to the user that match the given filters.

GET /outbound_voice_profiles

go
	page, err := client.OutboundVoiceProfiles.List(context.Background(), telnyx.OutboundVoiceProfileListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", page)

Returns: billing_group_id (uuid), call_recording (object), calling_window (object), concurrent_call_limit (integer | null), connections_count (integer), created_at (string), daily_spend_limit (string), daily_spend_limit_enabled (boolean), enabled (boolean), id (string), max_destination_rate (number), name (string), record_type (string), service_plan (enum: global), tags (arraystring]), traffic_type (enum: conversational), updated_at (string), usage_payment_method (enum: rate-deck), whitelisted_destinations (arraystring])

Create an outbound voice profile

Create an outbound voice profile.

POST /outbound_voice_profiles — Required: name

Optional: billing_group_id (uuid), call_recording (object), calling_window (object), concurrent_call_limit (integer | null), daily_spend_limit (string), daily_spend_limit_enabled (boolean), enabled (boolean), max_destination_rate (number), service_plan (enum: global), tags (arraystring]), traffic_type (enum: conversational), usage_payment_method (enum: rate-deck), whitelisted_destinations (arraystring])

go
	outboundVoiceProfile, err := client.OutboundVoiceProfiles.New(context.Background(), telnyx.OutboundVoiceProfileNewParams{
		Name: "office",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", outboundVoiceProfile.Data)

Returns: billing_group_id (uuid), call_recording (object), calling_window (object), concurrent_call_limit (integer | null), connections_count (integer), created_at (string), daily_spend_limit (string), daily_spend_limit_enabled (boolean), enabled (boolean), id (string), max_destination_rate (number), name (string), record_type (string), service_plan (enum: global), tags (arraystring]), traffic_type (enum: conversational), updated_at (string), usage_payment_method (enum: rate-deck), whitelisted_destinations (arraystring])

Retrieve an outbound voice profile

Retrieves the details of an existing outbound voice profile.

GET /outbound_voice_profiles/{id}

go
	outboundVoiceProfile, err := client.OutboundVoiceProfiles.Get(context.Background(), "1293384261075731499")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", outboundVoiceProfile.Data)

Returns: billing_group_id (uuid), call_recording (object), calling_window (object), concurrent_call_limit (integer | null), connections_count (integer), created_at (string), daily_spend_limit (string), daily_spend_limit_enabled (boolean), enabled (boolean), id (string), max_destination_rate (number), name (string), record_type (string), service_plan (enum: global), tags (arraystring]), traffic_type (enum: conversational), updated_at (string), usage_payment_method (enum: rate-deck), whitelisted_destinations (arraystring])

Updates an existing outbound voice profile.

PATCH /outbound_voice_profiles/{id} — Required: name

Optional: billing_group_id (uuid), call_recording (object), calling_window (object), concurrent_call_limit (integer | null), daily_spend_limit (string), daily_spend_limit_enabled (boolean), enabled (boolean), max_destination_rate (number), service_plan (enum: global), tags (arraystring]), traffic_type (enum: conversational), usage_payment_method (enum: rate-deck), whitelisted_destinations (arraystring])

go
	outboundVoiceProfile, err := client.OutboundVoiceProfiles.Update(
		context.Background(),
		"1293384261075731499",
		telnyx.OutboundVoiceProfileUpdateParams{
			Name: "office",
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", outboundVoiceProfile.Data)

Returns: billing_group_id (uuid), call_recording (object), calling_window (object), concurrent_call_limit (integer | null), connections_count (integer), created_at (string), daily_spend_limit (string), daily_spend_limit_enabled (boolean), enabled (boolean), id (string), max_destination_rate (number), name (string), record_type (string), service_plan (enum: global), tags (arraystring]), traffic_type (enum: conversational), updated_at (string), usage_payment_method (enum: rate-deck), whitelisted_destinations (arraystring])

Delete an outbound voice profile

Deletes an existing outbound voice profile.

DELETE /outbound_voice_profiles/{id}

go
	outboundVoiceProfile, err := client.OutboundVoiceProfiles.Delete(context.Background(), "1293384261075731499")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", outboundVoiceProfile.Data)

Returns: billing_group_id (uuid), call_recording (object), calling_window (object), concurrent_call_limit (integer | null), connections_count (integer), created_at (string), daily_spend_limit (string), daily_spend_limit_enabled (boolean), enabled (boolean), id (string), max_destination_rate (number), name (string), record_type (string), service_plan (enum: global), tags (arraystring]), traffic_type (enum: conversational), updated_at (string), usage_payment_method (enum: rate-deck), whitelisted_destinations (arraystring])