telnyx-porting-in-go-cf1258 — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited telnyx-porting-in-go-cf1258 (Agent Skill) and scored it 100/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 0 flagged
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
<!-- Auto-generated from Telnyx OpenAPI specs. Do not edit. -->
go get github.com/team-telnyx/telnyx-goimport (
"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")),
option.WithPublicKey(os.Getenv("TELNYX_PUBLIC_KEY")), // Required for client.Webhooks.Unwrap (webhook verification)
)All examples below assume client is already initialized as shown above.
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, then retry the request (bounded 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")
}
return err // Propagate: a failed request must never look like success to the caller
}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).
+13125550001). Include the + prefix and country code. No spaces, dashes, or parentheses.ListAutoPaging() for automatic iteration: iter := client.Resource.ListAutoPaging(ctx, params); for iter.Next() { item := iter.Current() }.Runs a portability check, returning the results immediately.
POST /portability_checks
Optional: phone_numbers (array[string])
response, err := client.PortabilityChecks.Run(context.Background(), telnyx.PortabilityCheckRunParams{
PhoneNumbers: []string{"+18005550101"},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: fast_portable (boolean), not_portable_reason (string), phone_number (string), portable (boolean), record_type (string)
Returns a paginated list of porting-related events on your account, such as status changes on porting orders. Supports filtering and is useful for auditing or reconciling webhook deliveries.
GET /porting/events
page, err := client.Porting.Events.List(context.Background(), telnyx.PortingEventListParams{})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: available_notification_methods (array[string]), event_type (enum: porting_order.deleted), id (uuid), payload (object), payload_status (enum: created, completed), porting_order_id (uuid)
Returns the details of a single porting event, including its type and payload.
GET /porting/events/{id}
event, err := client.Porting.Events.Get(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", event.Data)Returns: available_notification_methods (array[string]), event_type (enum: porting_order.deleted), id (uuid), payload (object), payload_status (enum: created, completed), porting_order_id (uuid)
Republishes the specified porting event, triggering re-delivery of the corresponding webhook to your account.
POST /porting/events/{id}/republish
err := client.Porting.Events.Republish(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}Returns a paginated list of your LOA (Letter of Authorization) configurations. LOA configurations customize the company details and branding used on generated LOA documents.
GET /porting/loa_configurations
page, err := client.Porting.LoaConfigurations.List(context.Background(), telnyx.PortingLoaConfigurationListParams{})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: address (object), company_name (string), contact (object), created_at (date-time), id (uuid), logo (object), name (string), organization_id (string), record_type (string), updated_at (date-time)
Creates a new LOA configuration with your company details and branding for use when generating LOA documents for porting orders.
POST /porting/loa_configurations
loaConfiguration, err := client.Porting.LoaConfigurations.New(context.Background(), telnyx.PortingLoaConfigurationNewParams{
Address: telnyx.PortingLoaConfigurationNewParamsAddress{
City: "Austin",
CountryCode: "US",
State: "TX",
StreetAddress: "600 Congress Avenue",
ZipCode: "78701",
},
CompanyName: "Telnyx",
Contact: telnyx.PortingLoaConfigurationNewParamsContact{
Email: "[email protected]",
PhoneNumber: "+12003270001",
},
Logo: telnyx.PortingLoaConfigurationNewParamsLogo{
DocumentID: "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
},
Name: "My LOA Configuration",
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", loaConfiguration.Data)Returns: address (object), company_name (string), contact (object), created_at (date-time), id (uuid), logo (object), name (string), organization_id (string), record_type (string), updated_at (date-time)
Preview the LOA template that would be generated without need to create LOA configuration.
POST /porting/loa_configurations/preview
response, err := client.Porting.LoaConfigurations.Preview(context.Background(), telnyx.PortingLoaConfigurationPreviewParams{
Address: telnyx.PortingLoaConfigurationPreviewParamsAddress{
City: "Austin",
CountryCode: "US",
State: "TX",
StreetAddress: "600 Congress Avenue",
ZipCode: "78701",
},
CompanyName: "Telnyx",
Contact: telnyx.PortingLoaConfigurationPreviewParamsContact{
Email: "[email protected]",
PhoneNumber: "+12003270001",
},
Logo: telnyx.PortingLoaConfigurationPreviewParamsLogo{
DocumentID: "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
},
Name: "My LOA Configuration",
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response)Returns the details of a single LOA (Letter of Authorization) configuration by its identifier.
GET /porting/loa_configurations/{id}
loaConfiguration, err := client.Porting.LoaConfigurations.Get(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", loaConfiguration.Data)Returns: address (object), company_name (string), contact (object), created_at (date-time), id (uuid), logo (object), name (string), organization_id (string), record_type (string), updated_at (date-time)
Updates the specified LOA configuration with the provided fields and returns the updated configuration.
PATCH /porting/loa_configurations/{id}
loaConfiguration, err := client.Porting.LoaConfigurations.Update(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingLoaConfigurationUpdateParams{
Address: telnyx.PortingLoaConfigurationUpdateParamsAddress{
City: "Austin",
CountryCode: "US",
State: "TX",
StreetAddress: "600 Congress Avenue",
ZipCode: "78701",
},
CompanyName: "Telnyx",
Contact: telnyx.PortingLoaConfigurationUpdateParamsContact{
Email: "[email protected]",
PhoneNumber: "+12003270001",
},
Logo: telnyx.PortingLoaConfigurationUpdateParamsLogo{
DocumentID: "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
},
Name: "My LOA Configuration",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", loaConfiguration.Data)Returns: address (object), company_name (string), contact (object), created_at (date-time), id (uuid), logo (object), name (string), organization_id (string), record_type (string), updated_at (date-time)
Permanently deletes the specified LOA configuration so it can no longer be used when generating LOA documents.
DELETE /porting/loa_configurations/{id}
err := client.Porting.LoaConfigurations.Delete(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}Renders a preview of the LOA document produced by this configuration so you can verify company details and branding before using it on porting orders.
GET /porting/loa_configurations/{id}/preview
response, err := client.Porting.LoaConfigurations.Preview1(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response)List the reports generated about porting operations.
GET /porting/reports
page, err := client.Porting.Reports.List(context.Background(), telnyx.PortingReportListParams{})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: created_at (date-time), document_id (uuid), id (uuid), params (object), record_type (string), report_type (enum: export_porting_orders_csv), status (enum: pending, completed), updated_at (date-time)
Generate reports about porting operations.
POST /porting/reports
report, err := client.Porting.Reports.New(context.Background(), telnyx.PortingReportNewParams{
Params: telnyx.ExportPortingOrdersCsvReportParam{
Filters: telnyx.ExportPortingOrdersCsvReportFiltersParam{},
},
ReportType: telnyx.PortingReportNewParamsReportTypeExportPortingOrdersCsv,
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", report.Data)Returns: created_at (date-time), document_id (uuid), id (uuid), params (object), record_type (string), report_type (enum: export_porting_orders_csv), status (enum: pending, completed), updated_at (date-time)
Returns the details of a previously requested porting report, including its status and parameters.
GET /porting/reports/{id}
report, err := client.Porting.Reports.Get(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", report.Data)Returns: created_at (date-time), document_id (uuid), id (uuid), params (object), record_type (string), report_type (enum: export_porting_orders_csv), status (enum: pending, completed), updated_at (date-time)
Returns the list of UK carriers available for porting, for use when preparing porting orders for UK numbers.
GET /porting/uk_carriers
response, err := client.Porting.ListUkCarriers(context.Background())
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: alternative_cupids (array[string]), created_at (date-time), cupid (string), id (uuid), name (string), record_type (string), updated_at (date-time)
Returns a paginated list of your porting orders. Supports filtering and sorting, and can optionally include the phone numbers attached to each order.
GET /porting_orders
page, err := client.PortingOrders.List(context.Background(), telnyx.PortingOrderListParams{})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: activation_settings (object), additional_steps (array[string]), created_at (date-time), customer_group_reference (string | null), customer_reference (string | null), description (string), documents (object), end_user (object), id (uuid), messaging (object), misc (object), old_service_provider_ocn (string), parent_support_key (string | null), phone_number_configuration (object), phone_number_type (enum: landline, local, localcommercial, mobile, multipurpose, national, other, shared_cost, toll_free), phone_numbers (array[object]), porting_phone_numbers_count (integer), record_type (string), requirements (array[object]), requirements_met (boolean), status (object), support_key (string | null), updated_at (date-time), user_feedback (object), user_id (uuid), webhook_url (uri)
Creates a new porting order to bring phone numbers from another carrier to Telnyx. Complete the order's requirements and then confirm it to submit the port.
POST /porting_orders — Required: phone_numbers
Optional: customer_group_reference (string), customer_reference (string | null)
portingOrder, err := client.PortingOrders.New(context.Background(), telnyx.PortingOrderNewParams{
PhoneNumbers: []string{"+13035550000", "+13035550001", "+13035550002"},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", portingOrder.Data)Returns: activation_settings (object), additional_steps (array[string]), created_at (date-time), customer_group_reference (string | null), customer_reference (string | null), description (string), documents (object), end_user (object), id (uuid), messaging (object), misc (object), old_service_provider_ocn (string), parent_support_key (string | null), phone_number_configuration (object), phone_number_type (enum: landline, local, localcommercial, mobile, multipurpose, national, other, shared_cost, toll_free), phone_numbers (array[object]), porting_phone_numbers_count (integer), record_type (string), requirements (array[object]), requirements_met (boolean), status (object), support_key (string | null), updated_at (date-time), user_feedback (object), user_id (uuid), webhook_url (uri)
Returns a list of all possible exception types for a porting order.
GET /porting_orders/exception_types
response, err := client.PortingOrders.GetExceptionTypes(context.Background())
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: code (enum: ACCOUNT_NUMBER_MISMATCH, AUTH_PERSON_MISMATCH, BTN_ATN_MISMATCH, ENTITY_NAME_MISMATCH, FOC_EXPIRED, FOC_REJECTED, LOCATION_MISMATCH, LSR_PENDING, MAIN_BTN_PORTING, OSP_IRRESPONSIVE, OTHER, PASSCODE_PIN_INVALID, PHONE_NUMBER_HAS_SPECIAL_FEATURE, PHONE_NUMBER_MISMATCH, PHONE_NUMBER_NOT_PORTABLE, PORT_TYPE_INCORRECT, PORTING_ORDER_SPLIT_REQUIRED, POSTAL_CODE_MISMATCH, RATE_CENTER_NOT_PORTABLE, SV_CONFLICT, SV_UNKNOWN_FAILURE), description (string)
Returns a list of phone number configurations paginated.
GET /porting_orders/phone_number_configurations
page, err := client.PortingOrders.PhoneNumberConfigurations.List(context.Background(), telnyx.PortingOrderPhoneNumberConfigurationListParams{})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: created_at (date-time), id (uuid), porting_phone_number_id (uuid), record_type (string), updated_at (date-time), user_bundle_id (uuid)
Creates a list of phone number configurations.
POST /porting_orders/phone_number_configurations
phoneNumberConfiguration, err := client.PortingOrders.PhoneNumberConfigurations.New(context.Background(), telnyx.PortingOrderPhoneNumberConfigurationNewParams{})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", phoneNumberConfiguration.Data)Returns: created_at (date-time), id (uuid), porting_phone_number_id (uuid), record_type (string), updated_at (date-time), user_bundle_id (uuid)
Retrieves the details of an existing porting order.
GET /porting_orders/{id}
portingOrder, err := client.PortingOrders.Get(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", portingOrder.Data)Returns: activation_settings (object), additional_steps (array[string]), created_at (date-time), customer_group_reference (string | null), customer_reference (string | null), description (string), documents (object), end_user (object), id (uuid), messaging (object), misc (object), old_service_provider_ocn (string), parent_support_key (string | null), phone_number_configuration (object), phone_number_type (enum: landline, local, localcommercial, mobile, multipurpose, national, other, shared_cost, toll_free), phone_numbers (array[object]), porting_phone_numbers_count (integer), record_type (string), requirements (array[object]), requirements_met (boolean), status (object), support_key (string | null), updated_at (date-time), user_feedback (object), user_id (uuid), webhook_url (uri)
Edits the details of an existing porting order. Any or all of a porting orders attributes may be included in the resource object included in a PATCH request. If a request does not include all of the attributes for a resource, the system will interpret the missing attributes as if they were included with their current values.
PATCH /porting_orders/{id}
Optional: activation_settings (object), customer_group_reference (string), customer_reference (string), documents (object), end_user (object), messaging (object), misc (object), phone_number_configuration (object), requirement_group_id (uuid), requirements (array[object]), user_feedback (object), webhook_url (uri)
portingOrder, err := client.PortingOrders.Update(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderUpdateParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", portingOrder.Data)Returns: activation_settings (object), additional_steps (array[string]), created_at (date-time), customer_group_reference (string | null), customer_reference (string | null), description (string), documents (object), end_user (object), id (uuid), messaging (object), misc (object), old_service_provider_ocn (string), parent_support_key (string | null), phone_number_configuration (object), phone_number_type (enum: landline, local, localcommercial, mobile, multipurpose, national, other, shared_cost, toll_free), phone_numbers (array[object]), porting_phone_numbers_count (integer), record_type (string), requirements (array[object]), requirements_met (boolean), status (object), support_key (string | null), updated_at (date-time), user_feedback (object), user_id (uuid), webhook_url (uri)
Deletes an existing porting order. This operation is restrict to porting orders in draft state.
DELETE /porting_orders/{id}
err := client.PortingOrders.Delete(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}Activate each number in a porting order asynchronously. This operation is limited to US FastPort orders only.
POST /porting_orders/{id}/actions/activate
response, err := client.PortingOrders.Actions.Activate(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: activate_at (date-time), activation_type (enum: scheduled, on-demand), activation_windows (array[object]), created_at (date-time), id (uuid), record_type (string), status (enum: created, in-process, completed, failed), updated_at (date-time)
Requests cancellation of the porting order and returns the updated order.
POST /porting_orders/{id}/actions/cancel
response, err := client.PortingOrders.Actions.Cancel(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: activation_settings (object), additional_steps (array[string]), created_at (date-time), customer_group_reference (string | null), customer_reference (string | null), description (string), documents (object), end_user (object), id (uuid), messaging (object), misc (object), old_service_provider_ocn (string), parent_support_key (string | null), phone_number_configuration (object), phone_number_type (enum: landline, local, localcommercial, mobile, multipurpose, national, other, shared_cost, toll_free), phone_numbers (array[object]), porting_phone_numbers_count (integer), record_type (string), requirements (array[object]), requirements_met (boolean), status (object), support_key (string | null), updated_at (date-time), user_feedback (object), user_id (uuid), webhook_url (uri)
Confirms the porting order and submits it for processing. Make sure all required information and documents are attached before confirming.
POST /porting_orders/{id}/actions/confirm
response, err := client.PortingOrders.Actions.Confirm(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: activation_settings (object), additional_steps (array[string]), created_at (date-time), customer_group_reference (string | null), customer_reference (string | null), description (string), documents (object), end_user (object), id (uuid), messaging (object), misc (object), old_service_provider_ocn (string), parent_support_key (string | null), phone_number_configuration (object), phone_number_type (enum: landline, local, localcommercial, mobile, multipurpose, national, other, shared_cost, toll_free), phone_numbers (array[object]), porting_phone_numbers_count (integer), record_type (string), requirements (array[object]), requirements_met (boolean), status (object), support_key (string | null), updated_at (date-time), user_feedback (object), user_id (uuid), webhook_url (uri)
Creates a sharing token for a porting order. The token can be used to share the porting order with non-Telnyx users.
POST /porting_orders/{id}/actions/share
response, err := client.PortingOrders.Actions.Share(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderActionShareParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: created_at (date-time), expires_at (date-time), expires_in_seconds (integer), id (uuid), permissions (array[string]), porting_order_id (uuid), record_type (string), token (string)
Returns a list of your porting activation jobs.
GET /porting_orders/{id}/activation_jobs
page, err := client.PortingOrders.ActivationJobs.List(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderActivationJobListParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: activate_at (date-time), activation_type (enum: scheduled, on-demand), activation_windows (array[object]), created_at (date-time), id (uuid), record_type (string), status (enum: created, in-process, completed, failed), updated_at (date-time)
Returns the details of a single activation job for the porting order, including its current status.
GET /porting_orders/{id}/activation_jobs/{activationJobId}
activationJob, err := client.PortingOrders.ActivationJobs.Get(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderActivationJobGetParams{
ID: "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", activationJob.Data)Returns: activate_at (date-time), activation_type (enum: scheduled, on-demand), activation_windows (array[object]), created_at (date-time), id (uuid), record_type (string), status (enum: created, in-process, completed, failed), updated_at (date-time)
Updates the activation time of a porting activation job.
PATCH /porting_orders/{id}/activation_jobs/{activationJobId}
activationJob, err := client.PortingOrders.ActivationJobs.Update(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderActivationJobUpdateParams{
ID: "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", activationJob.Data)Returns: activate_at (date-time), activation_type (enum: scheduled, on-demand), activation_windows (array[object]), created_at (date-time), id (uuid), record_type (string), status (enum: created, in-process, completed, failed), updated_at (date-time)
Returns a list of additional documents for a porting order.
GET /porting_orders/{id}/additional_documents
page, err := client.PortingOrders.AdditionalDocuments.List(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderAdditionalDocumentListParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: content_type (string), created_at (date-time), document_id (uuid), document_type (enum: loa, invoice, csr, other), filename (string), id (uuid), porting_order_id (uuid), record_type (string), updated_at (date-time)
Creates a list of additional documents for a porting order.
POST /porting_orders/{id}/additional_documents
additionalDocument, err := client.PortingOrders.AdditionalDocuments.New(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderAdditionalDocumentNewParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", additionalDocument.Data)Returns: content_type (string), created_at (date-time), document_id (uuid), document_type (enum: loa, invoice, csr, other), filename (string), id (uuid), porting_order_id (uuid), record_type (string), updated_at (date-time)
Deletes an additional document for a porting order.
DELETE /porting_orders/{id}/additional_documents/{additional_document_id}
err := client.PortingOrders.AdditionalDocuments.Delete(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderAdditionalDocumentDeleteParams{
ID: "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
},
)
if err != nil {
log.Fatal(err)
}Returns a list of allowed FOC dates for a porting order.
GET /porting_orders/{id}/allowed_foc_windows
response, err := client.PortingOrders.GetAllowedFocWindows(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: ended_at (date-time), record_type (string), started_at (date-time)
Returns a list of all comments of a porting order.
GET /porting_orders/{id}/comments
page, err := client.PortingOrders.Comments.List(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderCommentListParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: body (string), created_at (date-time), id (uuid), porting_order_id (uuid), record_type (string), user_type (enum: admin, user, system)
Creates a new comment for a porting order.
POST /porting_orders/{id}/comments
Optional: body (string)
comment, err := client.PortingOrders.Comments.New(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderCommentNewParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", comment.Data)Returns: body (string), created_at (date-time), id (uuid), porting_order_id (uuid), record_type (string), user_type (enum: admin, user, system)
Downloads the Letter of Authorization (LOA) template document for this porting order, optionally rendered with a specific LOA configuration.
GET /porting_orders/{id}/loa_template
response, err := client.PortingOrders.GetLoaTemplate(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderGetLoaTemplateParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response)Returns a list of all requirements based on country/number type for this porting order.
GET /porting_orders/{id}/requirements
page, err := client.PortingOrders.GetRequirements(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderGetRequirementsParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: field_type (enum: document, textual), field_value (string), record_type (string), requirement_status (string), requirement_type (object)
GET /porting_orders/{id}/sub_request
response, err := client.PortingOrders.GetSubRequest(context.Background(), "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: port_request_id (string), sub_request_id (string)
Returns a list of verification codes for a porting order.
GET /porting_orders/{id}/verification_codes
page, err := client.PortingOrders.VerificationCodes.List(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderVerificationCodeListParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: created_at (date-time), id (uuid), phone_number (string), porting_order_id (uuid), record_type (string), updated_at (date-time), verified (boolean)
Send the verification code for all porting phone numbers.
POST /porting_orders/{id}/verification_codes/send
err := client.PortingOrders.VerificationCodes.Send(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderVerificationCodeSendParams{},
)
if err != nil {
log.Fatal(err)
}Verifies the verification code for a list of phone numbers.
POST /porting_orders/{id}/verification_codes/verify
response, err := client.PortingOrders.VerificationCodes.Verify(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderVerificationCodeVerifyParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: created_at (date-time), id (uuid), phone_number (string), porting_order_id (uuid), record_type (string), updated_at (date-time), verified (boolean)
Returns a list of action requirements for a specific porting order.
GET /porting_orders/{porting_order_id}/action_requirements
page, err := client.PortingOrders.ActionRequirements.List(
context.Background(),
"porting_order_id",
telnyx.PortingOrderActionRequirementListParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: action_type (string), action_url (string | null), cancel_reason (string | null), created_at (date-time), id (string), porting_order_id (string), record_type (enum: porting_action_requirement), requirement_type_id (string), status (enum: created, pending, completed, cancelled, failed), updated_at (date-time)
Initiates a specific action requirement for a porting order.
POST /porting_orders/{porting_order_id}/action_requirements/{id}/initiate
response, err := client.PortingOrders.ActionRequirements.Initiate(
context.Background(),
"id",
telnyx.PortingOrderActionRequirementInitiateParams{
PortingOrderID: "550e8400-e29b-41d4-a716-446655440000",
Params: telnyx.PortingOrderActionRequirementInitiateParamsParams{
FirstName: "John",
LastName: "Doe",
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", response.Data)Returns: action_type (string), action_url (string | null), cancel_reason (string | null), created_at (date-time), id (string), porting_order_id (string), record_type (enum: porting_action_requirement), requirement_type_id (string), status (enum: created, pending, completed, cancelled, failed), updated_at (date-time)
Returns a list of all associated phone numbers for a porting order. Associated phone numbers are used for partial porting in GB to specify which phone numbers should be kept or disconnected.
GET /porting_orders/{porting_order_id}/associated_phone_numbers
page, err := client.PortingOrders.AssociatedPhoneNumbers.List(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderAssociatedPhoneNumberListParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: action (enum: keep, disconnect), country_code (string), created_at (date-time), id (uuid), phone_number_range (object), phone_number_type (enum: landline, local, mobile, national, shared_cost, toll_free), porting_order_id (uuid), record_type (string), updated_at (date-time)
Creates a new associated phone number for a porting order. This is used for partial porting in GB to specify which phone numbers should be kept or disconnected.
POST /porting_orders/{porting_order_id}/associated_phone_numbers
associatedPhoneNumber, err := client.PortingOrders.AssociatedPhoneNumbers.New(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderAssociatedPhoneNumberNewParams{
Action: telnyx.PortingOrderAssociatedPhoneNumberNewParamsActionKeep,
PhoneNumberRange: telnyx.PortingOrderAssociatedPhoneNumberNewParamsPhoneNumberRange{},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", associatedPhoneNumber.Data)Returns: action (enum: keep, disconnect), country_code (string), created_at (date-time), id (uuid), phone_number_range (object), phone_number_type (enum: landline, local, mobile, national, shared_cost, toll_free), porting_order_id (uuid), record_type (string), updated_at (date-time)
Deletes an associated phone number from a porting order.
DELETE /porting_orders/{porting_order_id}/associated_phone_numbers/{id}
associatedPhoneNumber, err := client.PortingOrders.AssociatedPhoneNumbers.Delete(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderAssociatedPhoneNumberDeleteParams{
PortingOrderID: "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", associatedPhoneNumber.Data)Returns: action (enum: keep, disconnect), country_code (string), created_at (date-time), id (uuid), phone_number_range (object), phone_number_type (enum: landline, local, mobile, national, shared_cost, toll_free), porting_order_id (uuid), record_type (string), updated_at (date-time)
Returns a list of all phone number blocks of a porting order.
GET /porting_orders/{porting_order_id}/phone_number_blocks
page, err := client.PortingOrders.PhoneNumberBlocks.List(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderPhoneNumberBlockListParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: activation_ranges (array[object]), country_code (string), created_at (date-time), id (uuid), phone_number_range (object), phone_number_type (enum: landline, local, localcommercial, mobile, multipurpose, national, other, shared_cost, toll_free), record_type (string), updated_at (date-time)
Creates a phone number block on the porting order, representing a contiguous range of phone numbers to be ported together.
POST /porting_orders/{porting_order_id}/phone_number_blocks
phoneNumberBlock, err := client.PortingOrders.PhoneNumberBlocks.New(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderPhoneNumberBlockNewParams{
ActivationRanges: []telnyx.PortingOrderPhoneNumberBlockNewParamsActivationRange{{
EndAt: "+4930244999910",
StartAt: "+4930244999901",
}},
PhoneNumberRange: telnyx.PortingOrderPhoneNumberBlockNewParamsPhoneNumberRange{
EndAt: "+4930244999910",
StartAt: "+4930244999901",
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", phoneNumberBlock.Data)Returns: activation_ranges (array[object]), country_code (string), created_at (date-time), id (uuid), phone_number_range (object), phone_number_type (enum: landline, local, localcommercial, mobile, multipurpose, national, other, shared_cost, toll_free), record_type (string), updated_at (date-time)
Deletes the specified phone number block from the porting order.
DELETE /porting_orders/{porting_order_id}/phone_number_blocks/{id}
phoneNumberBlock, err := client.PortingOrders.PhoneNumberBlocks.Delete(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderPhoneNumberBlockDeleteParams{
PortingOrderID: "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", phoneNumberBlock.Data)Returns: activation_ranges (array[object]), country_code (string), created_at (date-time), id (uuid), phone_number_range (object), phone_number_type (enum: landline, local, localcommercial, mobile, multipurpose, national, other, shared_cost, toll_free), record_type (string), updated_at (date-time)
Returns a list of all phone number extensions of a porting order.
GET /porting_orders/{porting_order_id}/phone_number_extensions
page, err := client.PortingOrders.PhoneNumberExtensions.List(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderPhoneNumberExtensionListParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: activation_ranges (array[object]), created_at (date-time), extension_range (object), id (uuid), porting_phone_number_id (uuid), record_type (string), updated_at (date-time)
Creates a phone number extension on the porting order, mapping extension ranges to one of the order's phone numbers.
POST /porting_orders/{porting_order_id}/phone_number_extensions
phoneNumberExtension, err := client.PortingOrders.PhoneNumberExtensions.New(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderPhoneNumberExtensionNewParams{
ActivationRanges: []telnyx.PortingOrderPhoneNumberExtensionNewParamsActivationRange{{
EndAt: 10,
StartAt: 1,
}},
ExtensionRange: telnyx.PortingOrderPhoneNumberExtensionNewParamsExtensionRange{
EndAt: 10,
StartAt: 1,
},
PortingPhoneNumberID: "f24151b6-3389-41d3-8747-7dd8c681e5e2",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", phoneNumberExtension.Data)Returns: activation_ranges (array[object]), created_at (date-time), extension_range (object), id (uuid), porting_phone_number_id (uuid), record_type (string), updated_at (date-time)
Deletes the specified phone number extension from the porting order.
DELETE /porting_orders/{porting_order_id}/phone_number_extensions/{id}
phoneNumberExtension, err := client.PortingOrders.PhoneNumberExtensions.Delete(
context.Background(),
"182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
telnyx.PortingOrderPhoneNumberExtensionDeleteParams{
PortingOrderID: "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", phoneNumberExtension.Data)Returns: activation_ranges (array[object]), created_at (date-time), extension_range (object), id (uuid), porting_phone_number_id (uuid), record_type (string), updated_at (date-time)
Returns a list of your porting phone numbers.
GET /porting_phone_numbers
page, err := client.PortingPhoneNumbers.List(context.Background(), telnyx.PortingPhoneNumberListParams{})
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+v\n", page)Returns: activation_status (enum: New, Pending, Conflict, Cancel Pending, Failed, Concurred, Activate RDY, Disconnect Pending, Concurrence Sent, Old, Sending, Active, Cancelled), phone_number (string), phone_number_type (enum: landline, local, localcommercial, mobile, multipurpose, national, other, shared_cost, toll_free), portability_status (enum: pending, confirmed, provisional), porting_order_id (uuid), porting_order_status (enum: draft, in-process, submitted, exception, foc-date-confirmed, cancel-pending, ported, cancelled), record_type (string), requirements_status (enum: requirement-info-pending, requirement-info-under-review, requirement-info-exception, approved), support_key (string)
~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.