How do I install the Telnyx Sip Integrations Go skill?

Run npx skillmds@latest add team-telnyx/telnyx-sip-integrations-go in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

What does the Telnyx Sip Integrations Go skill do?

Manage call recordings, media storage, Dialogflow integration, and external connections for SIP trunking. This skill provides Go SDK examples. It is listed under Integrations & APIs on SkillMD.

Is Telnyx Sip Integrations Go safe to use?

This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Telnyx Sip Integrations Go?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Telnyx Sip Integrations Go free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Telnyx Sip Integrations Go?

team-telnyx (@team-telnyx) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Telnyx Sip Integrations Go by team-telnyx

Name: Telnyx Sip Integrations Go
Author: team-telnyx

Telnyx Sip Integrations - Go

Installation

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

Setup

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:

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() }.

Retrieve a stored credential

Returns the information about custom storage credentials.

GET /custom_storage_credentials/{connection_id}

	customStorageCredential, err := client.CustomStorageCredentials.Get(context.Background(), "connection_id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", customStorageCredential.ConnectionID)

Returns: backend (enum: gcs, s3, azure), configuration (object)

Create a custom storage credential

Creates a custom storage credentials configuration.

POST /custom_storage_credentials/{connection_id}

	customStorageCredential, err := client.CustomStorageCredentials.New(
		context.Background(),
		"connection_id",
		telnyx.CustomStorageCredentialNewParams{
			CustomStorageConfiguration: telnyx.CustomStorageConfigurationParam{
				Backend: telnyx.CustomStorageConfigurationBackendGcs,
				Configuration: telnyx.CustomStorageConfigurationConfigurationUnionParam{
					OfGcs: &telnyx.GcsConfigurationDataParam{
						Backend: telnyx.GcsConfigurationDataBackendGcs,
					},
				},
			},
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", customStorageCredential.ConnectionID)

Returns: backend (enum: gcs, s3, azure), configuration (object)

Update a stored credential

Updates a stored custom credentials configuration.

PUT /custom_storage_credentials/{connection_id}

	customStorageCredential, err := client.CustomStorageCredentials.Update(
		context.Background(),
		"connection_id",
		telnyx.CustomStorageCredentialUpdateParams{
			CustomStorageConfiguration: telnyx.CustomStorageConfigurationParam{
				Backend: telnyx.CustomStorageConfigurationBackendGcs,
				Configuration: telnyx.CustomStorageConfigurationConfigurationUnionParam{
					OfGcs: &telnyx.GcsConfigurationDataParam{
						Backend: telnyx.GcsConfigurationDataBackendGcs,
					},
				},
			},
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", customStorageCredential.ConnectionID)

Returns: backend (enum: gcs, s3, azure), configuration (object)

Delete a stored credential

Deletes a stored custom credentials configuration.

DELETE /custom_storage_credentials/{connection_id}

	err := client.CustomStorageCredentials.Delete(context.Background(), "connection_id")
	if err != nil {
		log.Fatal(err)
	}

Retrieve stored Dialogflow Connection

Return details of the Dialogflow connection associated with the given CallControl connection.

GET /dialogflow_connections/{connection_id}

	dialogflowConnection, err := client.DialogflowConnections.Get(context.Background(), "connection_id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", dialogflowConnection.Data)

Returns: connection_id (string), conversation_profile_id (string), environment (string), record_type (string), service_account (string)

Create a Dialogflow Connection

Save Dialogflow Credentiails to Telnyx, so it can be used with other Telnyx services.

POST /dialogflow_connections/{connection_id}

	dialogflowConnection, err := client.DialogflowConnections.New(
		context.Background(),
		"connection_id",
		telnyx.DialogflowConnectionNewParams{
			ServiceAccount: map[string]any{
				"type":                        "bar",
				"project_id":                  "bar",
				"private_key_id":              "bar",
				"private_key":                 "bar",
				"client_email":                "bar",
				"client_id":                   "bar",
				"auth_uri":                    "bar",
				"token_uri":                   "bar",
				"auth_provider_x509_cert_url": "bar",
				"client_x509_cert_url":        "bar",
			},
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", dialogflowConnection.Data)

Returns: connection_id (string), conversation_profile_id (string), environment (string), record_type (string), service_account (string)

Update stored Dialogflow Connection

Updates a stored Dialogflow Connection.

PUT /dialogflow_connections/{connection_id}

	dialogflowConnection, err := client.DialogflowConnections.Update(
		context.Background(),
		"connection_id",
		telnyx.DialogflowConnectionUpdateParams{
			ServiceAccount: map[string]any{
				"type":                        "bar",
				"project_id":                  "bar",
				"private_key_id":              "bar",
				"private_key":                 "bar",
				"client_email":                "bar",
				"client_id":                   "bar",
				"auth_uri":                    "bar",
				"token_uri":                   "bar",
				"auth_provider_x509_cert_url": "bar",
				"client_x509_cert_url":        "bar",
			},
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", dialogflowConnection.Data)

Returns: connection_id (string), conversation_profile_id (string), environment (string), record_type (string), service_account (string)

Delete stored Dialogflow Connection

Deletes a stored Dialogflow Connection.

DELETE /dialogflow_connections/{connection_id}

	err := client.DialogflowConnections.Delete(context.Background(), "connection_id")
	if err != nil {
		log.Fatal(err)
	}

List all External Connections

This endpoint returns a list of your External Connections inside the 'data' attribute of the response. External Connections are used by Telnyx customers to seamless configure SIP trunking integrations with Telnyx Partners, through External Voice Integrations in Mission Control Portal.

GET /external_connections

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

Returns: active (boolean), created_at (string), credential_active (boolean), external_sip_connection (enum: zoom, operator_connect), id (string), inbound (object), outbound (object), record_type (string), tags (array[string]), updated_at (string), webhook_api_version (enum: 1, 2), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

Creates an External Connection

Creates a new External Connection based on the parameters sent in the request. The external_sip_connection and outbound voice profile id are required. Once created, you can assign phone numbers to your application using the /phone_numbers endpoint.

POST /external_connections — Required: external_sip_connection, outbound

Optional: active (boolean), inbound (object), tags (array[string]), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

	externalConnection, err := client.ExternalConnections.New(context.Background(), telnyx.ExternalConnectionNewParams{
		ExternalSipConnection: telnyx.ExternalConnectionNewParamsExternalSipConnectionZoom,
		Outbound:              telnyx.ExternalConnectionNewParamsOutbound{},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", externalConnection.Data)

List all log messages

Retrieve a list of log messages for all external connections associated with your account.

GET /external_connections/log_messages

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

Returns: log_messages (array[object]), meta (object)

Retrieve a log message

Retrieve a log message for an external connection associated with your account.

GET /external_connections/log_messages/{id}

	logMessage, err := client.ExternalConnections.LogMessages.Get(context.Background(), "1293384261075731499")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", logMessage.LogMessages)

Returns: log_messages (array[object])

Dismiss a log message

Dismiss a log message for an external connection associated with your account.

DELETE /external_connections/log_messages/{id}

	response, err := client.ExternalConnections.LogMessages.Dismiss(context.Background(), "1293384261075731499")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Success)

Returns: success (boolean)

Retrieve an External Connection

Return the details of an existing External Connection inside the 'data' attribute of the response.

GET /external_connections/{id}

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

Update an External Connection

Updates settings of an existing External Connection based on the parameters of the request.

PATCH /external_connections/{id} — Required: outbound

Optional: active (boolean), inbound (object), tags (array[string]), webhook_event_failover_url (uri), webhook_event_url (uri), webhook_timeout_secs (integer | null)

	externalConnection, err := client.ExternalConnections.Update(
		context.Background(),
		"1293384261075731499",
		telnyx.ExternalConnectionUpdateParams{
			Outbound: telnyx.ExternalConnectionUpdateParamsOutbound{
				OutboundVoiceProfileID: "1911630617284445511",
			},
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", externalConnection.Data)

Deletes an External Connection

Permanently deletes an External Connection. Deletion may be prevented if the application is in use by phone numbers, is active, or if it is an Operator Connect connection. To remove an Operator Connect integration please contact Telnyx support.

DELETE /external_connections/{id}

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

List all civic addresses and locations

Returns the civic addresses and locations from Microsoft Teams.

GET /external_connections/{id}/civic_addresses

	civicAddresses, err := client.ExternalConnections.CivicAddresses.List(
		context.Background(),
		"1293384261075731499",
		telnyx.ExternalConnectionCivicAddressListParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", civicAddresses.Data)

Returns: city_or_town (string), city_or_town_alias (string), company_name (string), country (string), country_or_district (string), default_location_id (uuid), description (string), house_number (string), house_number_suffix (string), id (uuid), locations (array[object]), postal_or_zip_code (string), record_type (string), state_or_province (string), street_name (string), street_suffix (string)

Retrieve a Civic Address

Return the details of an existing Civic Address with its Locations inside the 'data' attribute of the response.

GET /external_connections/{id}/civic_addresses/{address_id}

	civicAddress, err := client.ExternalConnections.CivicAddresses.Get(
		context.Background(),
		"318fb664-d341-44d2-8405-e6bfb9ced6d9",
		telnyx.ExternalConnectionCivicAddressGetParams{
			ID: "1293384261075731499",
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", civicAddress.Data)

Update a location's static emergency address

PATCH /external_connections/{id}/locations/{location_id} — Required: static_emergency_address_id

	response, err := client.ExternalConnections.UpdateLocation(
		context.Background(),
		"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
		telnyx.ExternalConnectionUpdateLocationParams{
			ID:                       "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
			StaticEmergencyAddressID: "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: accepted_address_suggestions (boolean), location_id (uuid), static_emergency_address_id (uuid)

List all phone numbers

Returns a list of all active phone numbers associated with the given external connection.

GET /external_connections/{id}/phone_numbers

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

Returns: acquired_capabilities (array[string]), civic_address_id (uuid), displayed_country_code (string), location_id (uuid), number_id (string), telephone_number (string), ticket_id (uuid)

Retrieve a phone number

Return the details of a phone number associated with the given external connection.

GET /external_connections/{id}/phone_numbers/{phone_number_id}

	phoneNumber, err := client.ExternalConnections.PhoneNumbers.Get(
		context.Background(),
		"1234567889",
		telnyx.ExternalConnectionPhoneNumberGetParams{
			ID: "1293384261075731499",
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", phoneNumber.Data)

Update a phone number

Asynchronously update settings of the phone number associated with the given external connection.

PATCH /external_connections/{id}/phone_numbers/{phone_number_id}

Optional: location_id (uuid)

	phoneNumber, err := client.ExternalConnections.PhoneNumbers.Update(
		context.Background(),
		"1234567889",
		telnyx.ExternalConnectionPhoneNumberUpdateParams{
			ID: "1293384261075731499",
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", phoneNumber.Data)

List all Releases

Returns a list of your Releases for the given external connection. These are automatically created when you change the connection_id of a phone number that is currently on Microsoft Teams.

GET /external_connections/{id}/releases

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

Returns: created_at (string), error_message (string), status (enum: pending_upload, pending, in_progress, complete, failed, expired, unknown), telephone_numbers (array[object]), tenant_id (uuid), ticket_id (uuid)

Retrieve a Release request

Return the details of a Release request and its phone numbers.

GET /external_connections/{id}/releases/{release_id}

	release, err := client.ExternalConnections.Releases.Get(
		context.Background(),
		"7b6a6449-b055-45a6-81f6-f6f0dffa4cc6",
		telnyx.ExternalConnectionReleaseGetParams{
			ID: "1293384261075731499",
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", release.Data)

List all Upload requests

Returns a list of your Upload requests for the given external connection.

GET /external_connections/{id}/uploads

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

Returns: available_usages (array[string]), error_code (string), error_message (string), location_id (uuid), status (enum: pending_upload, pending, in_progress, partial_success, success, error), tenant_id (uuid), ticket_id (uuid), tn_upload_entries (array[object])

Creates an Upload request

Creates a new Upload request to Microsoft teams with the included phone numbers. Only one of civic_address_id or location_id must be provided, not both. The maximum allowed phone numbers for the numbers_ids array is 1000.

POST /external_connections/{id}/uploads — Required: number_ids

Optional: additional_usages (array[string]), civic_address_id (uuid), location_id (uuid), usage (enum: calling_user_assignment, first_party_app_assignment)

	upload, err := client.ExternalConnections.Uploads.New(
		context.Background(),
		"1293384261075731499",
		telnyx.ExternalConnectionUploadNewParams{
			NumberIDs: []string{"3920457616934164700", "3920457616934164701", "3920457616934164702", "3920457616934164703"},
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", upload.TicketID)

Returns: success (boolean), ticket_id (uuid)

Refresh the status of all Upload requests

Forces a recheck of the status of all pending Upload requests for the given external connection in the background.

POST /external_connections/{id}/uploads/refresh

	response, err := client.ExternalConnections.Uploads.RefreshStatus(context.Background(), "1293384261075731499")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Success)

Returns: success (boolean)

Get the count of pending upload requests

Returns the count of all pending upload requests for the given external connection.

GET /external_connections/{id}/uploads/status

	response, err := client.ExternalConnections.Uploads.PendingCount(context.Background(), "1293384261075731499")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: pending_numbers_count (integer), pending_orders_count (integer)

Retrieve an Upload request

Return the details of an Upload request and its phone numbers.

GET /external_connections/{id}/uploads/{ticket_id}

	upload, err := client.ExternalConnections.Uploads.Get(
		context.Background(),
		"7b6a6449-b055-45a6-81f6-f6f0dffa4cc6",
		telnyx.ExternalConnectionUploadGetParams{
			ID: "1293384261075731499",
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", upload.Data)

Retry an Upload request

If there were any errors during the upload process, this endpoint will retry the upload request. In some cases this will reattempt the existing upload request, in other cases it may create a new upload request. Please check the ticket_id in the response to determine if a new upload request was created.

POST /external_connections/{id}/uploads/{ticket_id}/retry

	response, err := client.ExternalConnections.Uploads.Retry(
		context.Background(),
		"7b6a6449-b055-45a6-81f6-f6f0dffa4cc6",
		telnyx.ExternalConnectionUploadRetryParams{
			ID: "1293384261075731499",
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

List uploaded media

Returns a list of stored media files.

GET /media

	media, err := client.Media.List(context.Background(), telnyx.MediaListParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", media.Data)

Returns: content_type (string), created_at (string), expires_at (string), media_name (string), updated_at (string)

Upload media

Upload media file to Telnyx so it can be used with other Telnyx services

POST /media — Required: media_url

Optional: media_name (string), ttl_secs (integer)

	response, err := client.Media.Upload(context.Background(), telnyx.MediaUploadParams{
		MediaURL: "http://www.example.com/audio.mp3",
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Data)

Returns: content_type (string), created_at (string), expires_at (string), media_name (string), updated_at (string)

Retrieve stored media

Returns the information about a stored media file.

GET /media/{media_name}

	media, err := client.Media.Get(context.Background(), "media_name")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", media.Data)

Returns: content_type (string), created_at (string), expires_at (string), media_name (string), updated_at (string)

Update stored media

Updates a stored media file.

PUT /media/{media_name}

Optional: media_url (string), ttl_secs (integer)

	media, err := client.Media.Update(
		context.Background(),
		"media_name",
		telnyx.MediaUpdateParams{},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", media.Data)

Returns: content_type (string), created_at (string), expires_at (string), media_name (string), updated_at (string)

Deletes stored media

Deletes a stored media file.

DELETE /media/{media_name}

	err := client.Media.Delete(context.Background(), "media_name")
	if err != nil {
		log.Fatal(err)
	}

Download stored media

Downloads a stored media file.

GET /media/{media_name}/download

	response, err := client.Media.Download(context.Background(), "media_name")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response)

Refresh Operator Connect integration

This endpoint will make an asynchronous request to refresh the Operator Connect integration with Microsoft Teams for the current user. This will create new external connections on the user's account if needed, and/or report the integration results as log messages.

POST /operator_connect/actions/refresh

	response, err := client.OperatorConnect.Actions.Refresh(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", response.Message)

Returns: message (string), success (boolean)

List all recording transcriptions

Returns a list of your recording transcriptions.

GET /recording_transcriptions

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

Returns: created_at (string), duration_millis (int32), id (string), record_type (enum: recording_transcription), recording_id (string), status (enum: in-progress, completed), transcription_text (string), updated_at (string)

Retrieve a recording transcription

Retrieves the details of an existing recording transcription.

GET /recording_transcriptions/{recording_transcription_id}

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

Delete a recording transcription

Permanently deletes a recording transcription.

DELETE /recording_transcriptions/{recording_transcription_id}

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

List all call recordings

Returns a list of your call recordings.

GET /recordings

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

Returns: call_control_id (string), call_leg_id (string), call_session_id (string), channels (enum: single, dual), conference_id (string), connection_id (string), created_at (string), download_urls (object), duration_millis (int32), from (string), id (string), initiated_by (string), record_type (enum: recording), recording_ended_at (string), recording_started_at (string), source (enum: conference, call), status (enum: completed), to (string), updated_at (string)

Delete a list of call recordings

Permanently deletes a list of call recordings.

POST /recordings/actions/delete

	action, err := client.Recordings.Actions.Delete(context.Background(), telnyx.RecordingActionDeleteParams{
		IDs: []string{"428c31b6-7af4-4bcb-b7f5-5013ef9657c1", "428c31b6-7af4-4bcb-b7f5-5013ef9657c2"},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", action.Status)

Returns: status (enum: ok)

Retrieve a call recording

Retrieves the details of an existing call recording.

GET /recordings/{recording_id}

	recording, err := client.Recordings.Get(context.Background(), "recording_id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", recording.Data)

Delete a call recording

Permanently deletes a call recording.

DELETE /recordings/{recording_id}

	recording, err := client.Recordings.Delete(context.Background(), "recording_id")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", recording.Data)

Create a SIPREC connector

Creates a new SIPREC connector configuration.

POST /siprec_connectors

	siprecConnector, err := client.SiprecConnectors.New(context.Background(), telnyx.SiprecConnectorNewParams{
		Host: "siprec.telnyx.com",
		Name: "my-siprec-connector",
		Port: 5060,
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", siprecConnector.Data)

Returns: app_subdomain (string), created_at (string), host (string), name (string), port (integer), record_type (string), updated_at (string)

Retrieve a SIPREC connector

Returns details of a stored SIPREC connector.

GET /siprec_connectors/{connector_name}

	siprecConnector, err := client.SiprecConnectors.Get(context.Background(), "connector_name")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", siprecConnector.Data)

Returns: app_subdomain (string), created_at (string), host (string), name (string), port (integer), record_type (string), updated_at (string)

Update a SIPREC connector

Updates a stored SIPREC connector configuration.

PUT /siprec_connectors/{connector_name}

	siprecConnector, err := client.SiprecConnectors.Update(
		context.Background(),
		"connector_name",
		telnyx.SiprecConnectorUpdateParams{
			Host: "siprec.telnyx.com",
			Name: "my-siprec-connector",
			Port: 5060,
		},
	)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", siprecConnector.Data)

Returns: app_subdomain (string), created_at (string), host (string), name (string), port (integer), record_type (string), updated_at (string)

Delete a SIPREC connector

Deletes a stored SIPREC connector.

DELETE /siprec_connectors/{connector_name}

	err := client.SiprecConnectors.Delete(context.Background(), "connector_name")
	if err != nil {
		log.Fatal(err)
	}

Telnyx Sip Integrations Go

File contents

Telnyx Sip Integrations - Go

Installation

Setup

Error Handling

Important Notes

Retrieve a stored credential

Create a custom storage credential

Update a stored credential

Delete a stored credential

Retrieve stored Dialogflow Connection

Create a Dialogflow Connection

Update stored Dialogflow Connection

Delete stored Dialogflow Connection

List all External Connections

Creates an External Connection

List all log messages

Retrieve a log message

Dismiss a log message

Retrieve an External Connection

Update an External Connection

Deletes an External Connection

List all civic addresses and locations

Retrieve a Civic Address

Update a location's static emergency address

List all phone numbers

Retrieve a phone number

Update a phone number

List all Releases

Retrieve a Release request

List all Upload requests

Creates an Upload request

Refresh the status of all Upload requests

Get the count of pending upload requests

Retrieve an Upload request

Retry an Upload request

List uploaded media

Upload media

Retrieve stored media

Update stored media

Deletes stored media

Download stored media

Refresh Operator Connect integration

List all recording transcriptions

Retrieve a recording transcription

Delete a recording transcription

List all call recordings

Delete a list of call recordings

Retrieve a call recording

Delete a call recording

Create a SIPREC connector

Retrieve a SIPREC connector

Update a SIPREC connector

Delete a SIPREC connector

Related skills

Frequently asked questions

How do I install the Telnyx Sip Integrations Go skill?

What does the Telnyx Sip Integrations Go skill do?

Is Telnyx Sip Integrations Go safe to use?

Which AI agents work with Telnyx Sip Integrations Go?

Is Telnyx Sip Integrations Go free to use?

Who published Telnyx Sip Integrations Go?