Bindings

package main

import (
    "fmt"
    "github.com/telnyx/telnyx-go"
)

func main() {
    // SDK automatically uses TELNYX_API_KEY and TELNYX_BASE_URL
    client := telnyx.NewClient()

    // Get account balance
    balance, err := client.Balance.Get()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Printf("Balance: %s %s\n", balance.Balance, balance.Currency)
}

func sendMessage(to, from, text string) error {
    client := telnyx.NewClient()

    message, err := client.Messages.Create(&telnyx.MessageParams{
        From: from,
        To:   to,
        Text: text,
    })

    if err != nil {
        return err
    }

    fmt.Printf("Message sent: %s\n", message.ID)
    return nil
}

import telnyx

# SDK automatically uses TELNYX_API_KEY and TELNYX_BASE_URL
# No manual configuration needed!

def get_balance():
    """Retrieve account balance."""
    balance = telnyx.Balance.retrieve()
    return {
        "balance": balance.balance,
        "currency": balance.currency
    }

def send_message(to_number, from_number, text):
    """Send an SMS using Telnyx SDK."""
    message = telnyx.Message.create(
        from_=from_number,
        to=to_number,
        text=text
    )
    return {"message_id": message.id, "status": message.status}

def make_call(to_number, from_number, webhook_url):
    """Initiate an outbound call."""
    call = telnyx.Call.create(
        to=to_number,
        from_=from_number,
        connection_id="your-connection-id",
        webhook_url=webhook_url
    )
    return {"call_id": call.id}

import com.telnyx.sdk.ApiClient;
import com.telnyx.sdk.api.MessagesApi;
import com.telnyx.sdk.model.CreateMessageRequest;

@ApplicationScoped
public class MessageResource {

    // SDK automatically uses TELNYX_API_KEY and TELNYX_BASE_URL
    @Inject
    ApiClient telnyxClient;

    @POST
    @Path("/send")
    @Produces(MediaType.APPLICATION_JSON)
    public Response sendMessage(MessageRequest req) {
        MessagesApi api = new MessagesApi(telnyxClient);

        CreateMessageRequest request = new CreateMessageRequest()
            .from(req.getFrom())
            .to(req.getTo())
            .text(req.getText());

        var message = api.createMessage(request);

        return Response.ok(message).build();
    }
}

import os
import boto3

def get_storage_client():
    """Create a Cloud Storage client using a stored API key secret."""
    # Use a real API key stored as a secret, NOT the binding TELNYX_API_KEY
    api_key = os.environ.get('TELNYX_STORAGE_KEY')  # set via: telnyx-edge secrets add
    if not api_key:
        api_key = os.environ.get('TELNYX_API_KEY')  # fallback: only works with real API key, not binding JWT

    return boto3.client(
        's3',
        aws_access_key_id=api_key,
        aws_secret_access_key='',  # Not required for Telnyx
        endpoint_url='https://us-east-1.telnyxcloudstorage.com'
    )

def upload_file(bucket, key, data):
    """Upload a file to Cloud Storage."""
    client = get_storage_client()
    client.put_object(Bucket=bucket, Key=key, Body=data)
    return {"uploaded": key}

def download_file(bucket, key):
    """Download a file from Cloud Storage."""
    client = get_storage_client()
    response = client.get_object(Bucket=bucket, Key=key)
    return response['Body'].read()

def list_objects(bucket, prefix=''):
    """List objects in a bucket."""
    client = get_storage_client()
    response = client.list_objects_v2(Bucket=bucket, Prefix=prefix)
    return [obj['Key'] for obj in response.get('Contents', [])]