user@localhost ~ % aws configure --profile mytelnyxprofile
AWS Access Key ID [None]: XXX
AWS Secret Access Key [None]: XXX
Default region name [None]:
Default output format [None]: json

user@localhost ~ % aws configure list-profiles
mytelnyxprofile

user@localhost ~ % aws s3api create-bucket --bucket demo-bucket --profile mytelnyxprofile --endpoint-url https://us-east-1.telnyxcloudstorage.com
An error occurred (BucketAlreadyExists) when calling the CreateBucket operation: Unknown
user@localhost ~ % aws s3api create-bucket --bucket demo-bucket-n1 --profile mytelnyxprofile --endpoint-url https://us-east-1.telnyxcloudstorage.com
user@localhost ~ % aws s3api create-bucket --bucket demo-bucket-n2 --profile mytelnyxprofile --endpoint-url https://us-east-1.telnyxcloudstorage.com

user@localhost ~ % aws s3api list-buckets --profile mytelnyxprofile --endpoint-url https://us-east-1.telnyxcloudstorage.com
{
    "Buckets": [

        {
            "Name": "demo-bucket-n1",
            "CreationDate": "2024-07-26T17:31:14.888000+00:00"
        },
        {
            "Name": "demo-bucket-n2",
            "CreationDate": "2024-07-26T17:31:25.225000+00:00"
        }
    ],
    "Owner": {
        "DisplayName": "XXX",
        "ID": "XXX"
    }
}

user@localhost ~ % aws s3api put-object --key demo-obj-101 --body ~/Downloads/IMG_1752.mov --bucket demo-bucket-n1 --profile mytelnyxprofile --endpoint-url https://us-east-1.telnyxcloudstorage.com
{
    "ETag": "\"bc864c2bc4549d72abadb0a5d44ee788\""
}

user@localhost ~ % aws s3api put-object --key demo-obj-202 --body ~/Downloads/IMG_1753.mov --bucket demo-bucket-n1 --profile mytelnyxprofile --endpoint-url https://us-east-1.telnyxcloudstorage.com
{
    "ETag": "\"bc864c2bc4549d72babdb0a5d44ee988\""
}

user@localhost ~ % aws s3api list-objects-v2 --bucket demo-bucket-n1 --profile mytelnyxprofile --endpoint-url https://us-east-1.telnyxcloudstorage.com
{
    "Contents": [
        {
            "Key": "demo-obj-101",
            "LastModified": "2024-07-26T17:34:52.428000+00:00",
            "ETag": "\"bc864c2bc4549d72abadb0a5d44ee788\"",
            "Size": 136994934,
            "StorageClass": "STANDARD"
        },
        {
            "Key": "demo-obj-202",
            "LastModified": "2024-07-26T17:36:31.799000+00:00",
            "ETag": "\"bc864c2bc4549d72babdb0a5d44ee988\"",
            "Size": 136994934,
            "StorageClass": "STANDARD"
        }
    ],
    "RequestCharged": null
}

Authorization: AWS4-HMAC-SHA256
Credential={{your_telnyx_api_key_here}}/20221129/us-east-1/s3/aws4_request,
SignedHeaders=host;range;x-amz-date,
Signature=d82d11938fe5edf39a778ec710ac79899bae1d9a46ae36607be30fb55f655a3c

const { S3Client, CreateBucketCommand, PutObjectCommand, ListObjectsCommand, GetObjectCommand } = require("@aws-sdk/client-s3");
const axios = require("axios");
const { v4: uuidv4 } = require("uuid");

const telnyxApiKey = process.env.TELNYX_API_KEY;

if (!telnyxApiKey) {
  console.error("TELNYX_API_KEY environment variable not set");
  process.exit(1);
}

const endpointUrl = "https://us-central-1.telnyxcloudstorage.com";

// 1. Initialize the AWS S3 client with specific options
const s3Client = new S3Client({
  endpoint: endpointUrl,
  region: "us-central-1",
  credentials: {
    accessKeyId: telnyxApiKey,
    secretAccessKey: telnyxApiKey
  },
  forcePathStyle: true,
  requestChecksumCalculation: 'WHEN_REQUIRED',
  requestChecksumValidation: 'WHEN_REQUIRED',
  responseChecksumCalculation: 'WHEN_REQUIRED',
  responseChecksumValidation: 'WHEN_REQUIRED'
});

(async () => {
  // 2. Create a bucket
  const bucketName = `my-test-bucket-${uuidv4()}`;
  await s3Client.send(new CreateBucketCommand({ Bucket: bucketName }));

  // 3. Upload two objects with random data
  for (let i = 0; i < 2; i++) {
    const name = `my-test-object-${i}`;
    const body = `Telnyx Cloud Storage ${i}`;
    await s3Client.send(new PutObjectCommand({ Bucket: bucketName, Key: name, Body: body }));
  }

  // 4. List objects in the bucket
  const listResult = await s3Client.send(new ListObjectsCommand({ Bucket: bucketName }));
  (listResult.Contents || []).forEach(obj => {
    console.log(obj.Key);
  });

  // 5. Download the first object
  const getResult = await s3Client.send(new GetObjectCommand({ Bucket: bucketName, Key: "my-test-object-0" }));
  const streamToString = (stream) => new Promise((resolve, reject) => {
    const chunks = [];
    stream.on("data", (chunk) => chunks.push(chunk));
    stream.on("error", reject);
    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
  });
  console.log(await streamToString(getResult.Body));

  // 6. Create a presigned URL for the first file
  const presignResponse = await axios.post(
    `https://api.telnyx.com/v2/storage/buckets/${bucketName}/my-test-object-0/presigned_url`,
    { ttl: 30 },
    { headers: { Authorization: `Bearer ${telnyxApiKey}` } }
  );
  console.log(presignResponse.data);

  // 7. Download the file using the presigned URL
  const fileResponse = await axios.get(presignResponse.data.data.presigned_url);
  console.log(fileResponse.data);
})();

import requests
import uuid
import os
from botocore.config import Config
import boto3

# Only perform CRC checks `when_required`
config = Config(
    request_checksum_calculation="when_required",
    response_checksum_validation="when_required",
)

telnyx_api_key = os.getenv("TELNYX_API_KEY")

if not telnyx_api_key:
  print("TELNYX_API_KEY environment variable not set")
  exit(1)

# 1. Initialize the AWS client with specific options
client = boto3.client(
  "s3",
  endpoint_url="https://us-central-1.telnyxcloudstorage.com",
  aws_access_key_id=telnyx_api_key,
  aws_secret_access_key=telnyx_api_key,
  config=config
)

# 2. Create a bucket
bucket_name = f"my-test-bucket-{uuid.uuid4()}"

client.create_bucket(Bucket=bucket_name)

# 3. Upload two objects with random data
for i in range(2):
  name = f"my-test-object-{i}"
  body = f"Telnyx Cloud Storage {i}"

  client.put_object(Bucket=bucket_name, Key=name, Body=body)

# 4. List objects in the bucket
for obj in client.list_objects(Bucket=bucket_name)["Contents"]:
  print(obj["Key"])

# 5. Download the first object
result = client.get_object(Bucket=bucket_name, Key="my-test-object-0")

print(result["Body"].read())

# 6. Create a presigned URL for the first file
response = requests.post(
  f"https://api.telnyx.com/v2/storage/buckets/{bucket_name}/my-test-object-0/presigned_url",
  json={"ttl": 30},
  headers={"Authorization": f"Bearer {telnyx_api_key}"},
)

body = response.json()

print(body)

# 7. Download the file using the presigned URL
response = requests.get(body["data"]["presigned_url"])

print(response.text)

  software.amazon.awssdk
  s3
  2.20.0 <!--  Or any 2.x version -->

import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.CreateBucketRequest;

import java.net.URI;

public class CreateBucket {

  public static void main(String[] args) {
      String bucketName = "--your-bucket-name--";
      Region region = Region.US_EAST_1;
      String telnyxUrl = "https://us-central-1.telnyxcloudstorage.com";
      String telnyxApiKey = "-- api key --";

      // Create an S3 client
      S3Client s3 = S3Client.builder()
              .region(region)
              .endpointOverride(URI.create(telnyxUrl))
                // Only perform CRC checks `when_required`
                .requestChecksumCalculation(RequestChecksumCalculation.WHEN_REQUIRED)
                .responseChecksumValidation(ResponseChecksumValidation.WHEN_REQUIRED)
              .credentialsProvider(
                      StaticCredentialsProvider.create(AwsBasicCredentials.create(telnyxApiKey, "does not matter")))
              .build();

      // create bucket
      CreateBucketRequest createBucketRequest = CreateBucketRequest.builder()
              .bucket(bucketName)
              .build();

      s3.createBucket(createBucketRequest);
      System.out.println("Bucket created successfully: " + bucketName);

      // Close the S3 client
      s3.close();
  }

}

import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;

import java.net.URI;
import java.nio.file.Paths;

public class UploadObjectToS3 {

  public static void main(String[] args) {
      String bucketName = "--your-bucket-name--";
      String keyName = "your-object-key";
      String filePath = "--path to file for upload--";

      Region region = Region.US_EAST_1;
      String telnyxUrl = "https://us-central-1.telnyxcloudstorage.com";
      String telnyxApiKey = "--your api key --";

      // Create an S3 client
      S3Client s3 = S3Client.builder()
              .region(region)
              .endpointOverride(URI.create(telnyxUrl))
              .credentialsProvider(
                      StaticCredentialsProvider.create(AwsBasicCredentials.create(telnyxApiKey, "does not matter")))
              .build();

      // upload object
      PutObjectRequest putObjectRequest = PutObjectRequest.builder()
              .bucket(bucketName)
              .key(keyName)
              .build();

      // Upload the file to S3
      s3.putObject(putObjectRequest, RequestBody.fromFile(Paths.get(filePath)));

      // Close the S3 client
      s3.close();
  }

}

import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;
import software.amazon.awssdk.services.s3.model.S3Object;

import java.net.URI;

public class ListObjects {

  public static void main(String[] args) {
      String bucketName = "--your-bucket-name--";
      Region region = Region.US_EAST_1;
      String telnyxUrl = "https://us-central-1.telnyxcloudstorage.com";
      String telnyxApiKey = "--your api key --";

      // Create an S3 client
      S3Client s3 = S3Client.builder()
              .region(region)
              .endpointOverride(URI.create(telnyxUrl))
              .credentialsProvider(
                      StaticCredentialsProvider.create(AwsBasicCredentials.create(telnyxApiKey, "does not matter")))
              .build();
      // Create a ListObjectsV2Request
      ListObjectsV2Request listObjectsRequest = ListObjectsV2Request.builder()
              .bucket(bucketName)
              .build();

      // Get the list of objects in the bucket
      ListObjectsV2Response listObjectsResponse = s3.listObjectsV2(listObjectsRequest);

      for (S3Object s3Object : listObjectsResponse.contents()) {
          System.out.println( s3Object.key());
      }

      // Close the S3 client
      s3.close();
  }

}

import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.core.ResponseBytes;
import software.amazon.awssdk.core.sync.ResponseTransformer;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;

public class DownloadObject {

  public static void main(String[] args) throws IOException {
      String bucketName = "--your-bucket-name--";
      Region region = Region.US_EAST_1;
      String telnyxUrl = "https://us-central-1.telnyxcloudstorage.com";
      String telnyxApiKey = "--your api key --";
      String keyName = "your-object-key";

      S3Client s3 = S3Client.builder()
              .region(region)
              .endpointOverride(URI.create(telnyxUrl))
              .credentialsProvider(
                      StaticCredentialsProvider.create(AwsBasicCredentials.create(telnyxApiKey, "does not matter")))
              .build();

      // Create a GetObjectRequest
      GetObjectRequest getObjectRequest = GetObjectRequest.builder()
              .bucket(bucketName)
              .key(keyName)
              .build();

      // Download the object and transform the response to a byte array
      ResponseBytes objectBytes = s3.getObject(getObjectRequest, ResponseTransformer.toBytes());

      // Write the file to the specified path
      File downloadedFile = new File("-- path to where to save the file --");
      try (FileOutputStream fos = new FileOutputStream(downloadedFile)) {
          fos.write(objectBytes.asByteArray());
          System.out.println("File downloaded successfully to -- path to where to save the file --");
      }

      // Close the S3 client
      s3.close();
  }

}

      com.squareup.okhttp3
      okhttp
      4.9.2

      com.google.code.gson
      gson
      2.8.7

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import okhttp3.*;

import java.io.IOException;
import java.util.Map;

public class GeneratePresignedURLAndDownloadObject {

  public static void main(String[] args) throws IOException {
      OkHttpClient httpClient = new OkHttpClient();
      Gson gson = new Gson();

      String presignedUrlRequestJson = gson.toJson(Map.of("ttl", 30));
      RequestBody presignedUrlRequestBody = RequestBody.create(MediaType.parse("application/json"), presignedUrlRequestJson);

      Request presignedUrlRequest = new Request.Builder()
              .url("https://api.telnyx.com/v2/storage/buckets/-- name of the bucket --/--name of the object--/presigned_url")
              .header("Authorization", "Bearer --your api key---")
              .post(presignedUrlRequestBody)
              .build();

      try (Response response = httpClient.newCall(presignedUrlRequest).execute()) {
          if (!response.isSuccessful()) {
              throw new IOException("Failed to create presigned URL: " + response);
          }
          String responseBody = response.body().string();
          Map responseBodyMap = gson.fromJson(responseBody, new TypeToken>() {}.getType());
          String presignedUrl = ((Map) responseBodyMap.get("data")).get("presigned_url");

          System.out.println("Presigned URL: " + presignedUrl);

          // 6. Download the file using the presigned URL
          Request downloadRequest = new Request.Builder()
                  .url(presignedUrl)
                  .build();

          try (Response downloadResponse = httpClient.newCall(downloadRequest).execute()) {
              if (!downloadResponse.isSuccessful()) {
                  throw new IOException("Failed to download file using presigned URL: " + downloadResponse);
              }
              System.out.println("Downloaded via presigned URL: " + downloadResponse.body().string());
          }
      }
  }
}

package main

import (
  "bytes"
  "context"
  crand "crypto/rand"
  "encoding/json"
  "fmt"
  "io"
  "log"
  "math/rand"
  "net/http"
  "os"
  "time"

  "github.com/aws/aws-sdk-go-v2/aws"
  "github.com/aws/aws-sdk-go-v2/config"
  "github.com/aws/aws-sdk-go-v2/service/s3"
)

func main() {
  ctx := context.Background()
  randSeq := rand.Intn(1_000_000)

  telnyxAPIKey := os.Getenv("TELNYX_API_KEY")
  if telnyxAPIKey == "" {
      log.Fatal("TELNYX_API_KEY environment variable not set")
  }

  region := "us-central-1"
  endpoint := fmt.Sprintf("https://%s.telnyxcloudstorage.com", region)

  // 1. Initializing the AWS client with specific options
  cfg, err := config.LoadDefaultConfig(ctx,
      config.WithRegion(region),
      config.WithCredentialsProvider(aws.CredentialsProviderFunc(
          func(context.Context) (aws.Credentials, error) {
              return aws.Credentials{
                  AccessKeyID:   telnyxAPIKey, // Use your Telnyx API key
                  SecretAccessKey: telnyxAPIKey, // Optional, can be left blank
              }, nil
          })),
      config.WithS3UseARNRegion(true),
      config.WithS3DisableExpressAuth(true),
      config.WithS3DisableMultiRegionAccessPoints(true),
  )
  if err != nil {
      log.Fatalf("s3 configuration error: %v", err)
  }
  cfg.BaseEndpoint = aws.String(endpoint)

  s3Client := s3.NewFromConfig(cfg)
  log.Printf("Created S3 client for region (%v) and endpoint (%v)", cfg.Region, *cfg.BaseEndpoint)

  // test-bucket-us-central-1.23-34.randomNumber
  ts := time.Now()
  bucketName := fmt.Sprintf("%v-%s.%v-%v.%v", "test-bucket", region, ts.Hour(), ts.Minute(), randSeq)
  log.Printf("Generated bucket name: %q", bucketName)

  // Create two objects in memory
  objs := make(map[string]*bytes.Reader)
  noFiles := 2
  for i := 0; i < noFiles; i++ {
      ct := make([]byte, 1024*32)
      // fill with random data
      if _, err := crand.Read(ct); err != nil {
          log.Fatalf("failed to read random data: %v", err)
      }

      objName := fmt.Sprintf("%v.txt", i)
      objs[objName] = bytes.NewReader(ct)
  }

  // 2. Create a bucket
  _, err = s3Client.CreateBucket(ctx, &s3.CreateBucketInput{
      Bucket: aws.String(bucketName),
  })
  if err != nil {
      log.Fatalf("unable to create bucket: %v", err)
  }
  log.Printf("Created bucket: %v", bucketName)

  // 3. Upload the two objects into the newly created bucket
  for objName, body := range objs {
      if _, err = s3Client.PutObject(ctx, &s3.PutObjectInput{
          Bucket: aws.String(bucketName),
          Key:  aws.String(objName),
          Body:   body,
      }); err != nil {
          log.Fatalf("unable to upload file (%v): %v", objName, err)
      }

      log.Printf("Uploaded file (%v) to bucket: %v", objName, bucketName)
  }

  // 4. List objects in the bucket
  listObj, err := s3Client.ListObjectsV2(ctx, &s3.ListObjectsV2Input{
      Bucket: aws.String(bucketName),
  })
  if err != nil {
      log.Fatalf("unable to list objects: %v", err)
  }

  for _, item := range listObj.Contents {
      log.Printf("Listed object: %v", *item.Key)
  }

  // 5. Download the object first
  out, err := s3Client.GetObject(ctx, &s3.GetObjectInput{
      Bucket: aws.String(bucketName),
      Key:  aws.String("1.txt"),
  })
  if err != nil {
      log.Fatalf("unable to download object: %v", err)
  }
  defer out.Body.Close()

  dl, err := io.ReadAll(out.Body)
  if err != nil {
      log.Fatalf("unable to read object data: %v", err)
  }

  log.Printf("downloaded file size: %d", len(dl))

  // 6. Create a presigned URL for the first file
  url := fmt.Sprintf("https://api.telnyx.com/v2/storage/buckets/%v/%v/presigned_url", bucketName, "1.txt")

  req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader([]byte(`{"ttl": 30}`)))
  if err != nil {
      log.Fatalf("unable to create presigned request: %v", err)
  }
  req.Header.Set("Authorization", "Bearer "+telnyxAPIKey)

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
      log.Fatalf("unable to send presigned request: %v", err)
  }
  defer resp.Body.Close()

  if resp.StatusCode != http.StatusOK {
      b, _ := io.ReadAll(resp.Body)
      log.Fatalf("unexpected status code: %v | response: %s", resp.StatusCode, b)
  }

  type presignedURL struct {
      Data struct {
          Token      string  `json:"token"`
          ExpiresAt  time.Time `json:"expires_at"`
          PresignedURL string  `json:"presigned_url"`
      } `json:"data"`
  }

  var purl presignedURL
  if err := json.NewDecoder(resp.Body).Decode(&purl); err != nil {
      log.Fatalf("unable to decode presigned URL: %v", err)
  }

  log.Printf("Generated presigned URL: %v", purl.Data.PresignedURL)

  // 7. Download the file again using the presigned URL
  res, err := http.Get(purl.Data.PresignedURL)
  if err != nil {
      log.Fatalf("unable to download presigned URL: %v", err)
  }
  defer res.Body.Close()

  log.Printf("Downloaded presigned URL status code: %v", res.StatusCode)
}

TELNYX_API_KEY=_YOUR_API_KEY go run main.go

2024/08/15 13:14:29 Created S3 client for region (us-central-1) and endpoint (https://us-central-1.telnyxcloudstorage.com)
2024/08/15 13:14:29 Generated bucket name: "test-bucket-us-central-1.13-14.536341"
2024/08/15 13:14:30 Created bucket: test-bucket-us-central-1.13-14.536341
2024/08/15 13:14:31 Uploaded file (0.txt) to bucket: test-bucket-us-central-1.13-14.536341
2024/08/15 13:14:31 Uploaded file (1.txt) to bucket: test-bucket-us-central-1.13-14.536341
2024/08/15 13:14:31 Listed object: 0.txt
2024/08/15 13:14:31 Listed object: 1.txt
2024/08/15 13:14:32 downloaded file size: 32768
2024/08/15 13:14:32 Generated presigned URL: https://us-central-1.telnyxcloudstorage.com/test-bucket-us-central-1.13-14.536341/1.txt?X-AMZ-Security-Token=sometoken
2024/08/15 13:14:33 Downloaded presigned URL status code: 200

require "aws-sdk-s3"
require "net/http"
require "securerandom"
require "json"

# Create a new S3 resource

telnyx_api_key = ENV["TELNYX_API_KEY"]

resource = Aws::S3::Resource.new(
  region: "us-central-1",
  endpoint: "https://us-central-1.telnyxcloudstorage.com",
  access_key_id: telnyx_api_key,
  secret_access_key: "doesn't matter"
  )

  bucket_name = "example-#{SecureRandom.hex(24)}"

# Creating a bucket
bucket = resource.create_bucket(bucket: bucket_name)

puts "*" * 50
puts("Created bucket named #{bucket.name}.")
puts "*" * 50

# Listing buckets

puts "Listing buckets"
puts "*" * 50

resource.buckets.each do |b|
  puts " - #{b.name}"
end

puts "*" * 50

# Upload a file

File.open("document.txt", "w+") { |f| f.write("This is a text document.\n") }

bucket = resource.bucket(bucket_name)
the_object = bucket.object("document.txt")
the_object.upload_file("document.txt")

puts("Uploaded file document.txt into bucket #{bucket.name} with key #{the_object.key}.")
puts "*" * 50

# Download an object from the bucket
puts "Downloading object from bucket #{bucket.name}"
file_name = "a-local-file.txt"
the_object.download_file(file_name)
puts("Object #{the_object.key} successfully downloaded to #{file_name}.")
puts("Contents of #{file_name}: #{File.read(file_name).inspect}")
puts "*" * 50

# Creating a presigned URL to upload a file
object_key = "important-document.txt"
uri = URI("https://api.telnyx.com/v2/storage/buckets/#{bucket_name}/#{object_key}/presigned_url")

response = Net::HTTP.post(
  uri,
  { ttl: 30 }.to_json,
  "Authorization" => "Bearer #{telnyx_api_key}"
)

raise "Bad response creating presigned URL" unless response.code == "200"

parsed_response = JSON.parse(response.body)
presigned_url = parsed_response["data"]["presigned_url"]
puts "Created presigned upload URL:"
puts "*" * 50
puts presigned_url
puts "*" * 50

# Upload a file using the Telnyx presigned URL
uri = URI(presigned_url)
request = Net::HTTP.new(uri.host)
response = request.put(uri, "This is an important text document.\n")

raise "Couldn't upload file using presigned URL: #{response.inspect}" unless response.code == "200"

puts "Uploaded file using presigned URL: #{response.inspect}"

# Listing objects in the bucket

puts "Listing objects in bucket #{bucket.name}"
puts "*" * 50

bucket.objects.each do |o|
  puts " * #{o.key}"
end

puts "*" * 50

# Creating a presigned URL to download the file
uri = URI("https://api.telnyx.com/v2/storage/buckets/#{bucket_name}/#{object_key}/presigned_url")

response = Net::HTTP.post(
  uri,
  { ttl: 30 }.to_json,
  "Authorization" => "Bearer #{telnyx_api_key}"
)

raise "Bad response creating presigned URL" unless response.code == "200"

parsed_response = JSON.parse(response.body)
presigned_url = parsed_response["data"]["presigned_url"]
puts "Created presigned download URL:"
puts "*" * 50
puts presigned_url
puts "*" * 50

# Download the object using the presigned URL

uri = URI(presigned_url)
response = Net::HTTP.get(uri)
puts("Downloaded object contents from presigned URL: #{response.inspect}")
puts "*" * 50

# Cleaning up

File.delete("document.txt")
File.delete("a-local-file.txt")

# Deleting the objects

the_object.delete
puts("Deleted object #{the_object.key}.")
important_object = bucket.object(object_key)
important_object.delete
puts("Deleted object #{important_object.key}.")

# Deleting the bucket

bucket.delete
puts("Deleted bucket #{bucket.name}.")
puts("Done.")

<?php
require 'vendor/autoload.php';

use Aws\S3\S3Client;
use Aws\Credentials\CredentialProvider;
use Aws\Exception\AwsException;

$telnyxAPIKey = getenv('TELNYX_API_KEY');
if (!$telnyxAPIKey) {
  die('TELNYX_API_KEY environment variable not set');
}

$region = 'us-central-1';
$endpoint = "https://{$region}.telnyxcloudstorage.com";

// 1. Initializing the AWS client with specific options
$s3Client = new S3Client([
  'region'  => $region,
  'version' => 'latest',
  'endpoint' => $endpoint,
  'credentials' => [
      'key'  => $telnyxAPIKey,
      'secret' => $telnyxAPIKey,
  ],
  'use_path_style_endpoint' => true
]);

$bucketName = "test-bucket-" . $region . '-' . date('H-i') . '-' . rand(0, 1000000);
echo "Generated bucket name: " . $bucketName . PHP_EOL;

// 2. Create a bucket
try {
  $s3Client->createBucket([
      'Bucket' => $bucketName
  ]);
  echo "Created bucket: {$bucketName}" . PHP_EOL;
} catch (AwsException $e) {
  die("Unable to create bucket: " . $e->getMessage());
}

// 3. Upload two objects with random data
for ($i = 0; $i < 2; $i++) {
  $content = random_bytes(1024 * 32); // 32KB of random data
  $objName = "{$i}.txt";
  try {
      $s3Client->putObject([
          'Bucket' => $bucketName,
          'Key'  => $objName,
          'Body'   => $content
      ]);
      echo "Uploaded file ({$objName}) to bucket: {$bucketName}" . PHP_EOL;
  } catch (AwsException $e) {
      die("Unable to upload file ({$objName}): " . $e->getMessage());
  }
}

// 4. List objects in the bucket
try {
  $result = $s3Client->listObjects([
      'Bucket' => $bucketName
  ]);
  foreach ($result['Contents'] as $item) {
      echo "Listed object: " . $item['Key'] . PHP_EOL;
  }
} catch (AwsException $e) {
  die("Unable to list objects: " . $e->getMessage());
}

// 5. Download the first object
try {
  $result = $s3Client->getObject([
      'Bucket' => $bucketName,
      'Key'  => '1.txt'
  ]);
  $data = $result['Body']->getContents();
  echo "Downloaded file size: " . strlen($data) . PHP_EOL;
} catch (AwsException $e) {
  die("Unable to download object: " . $e->getMessage());
}

// 6. Create a presigned URL for the first file
$url = "https://api.telnyx.com/v2/storage/buckets/{$bucketName}/1.txt/presigned_url";

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(['ttl' => 30]));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'Authorization: Bearer ' . $telnyxAPIKey,
  'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$httpcode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpcode != 200) {
  die("Unexpected status code: {$httpcode} | response: {$response}");
}

$presignedData = json_decode($response, true);
$presignedURL = $presignedData['data']['presigned_url'];
echo "Generated presigned URL: {$presignedURL}" . PHP_EOL;

// 7. Download the file using the presigned URL
$ch = curl_init($presignedURL);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close($ch);

echo "Downloaded presigned URL data size: " . strlen($result) . PHP_EOL;
?>

using System.Text;
using System.Text.Json;
using Amazon.Runtime;
using Amazon.S3;
using Amazon.S3.Model;

// 1. Configure and create Telnyx API Client

var apiKeyTelnyx = "API-KEY-HERE";
var bucketName = "BUCKET-NAME-HERE";
var objectName = "OBJECT-NAME-HERE";
var region = "us-central-1";

var s3Config = new AmazonS3Config
{
   ServiceURL = $"https://{region}.telnyxcloudstorage.com",
   ForcePathStyle = true,
   LogResponse = true,
   DisableLogging = false,
   SignatureVersion = "4",
};

var telnyxClient = new AmazonS3Client(
   new BasicAWSCredentials(apiKeyTelnyx, apiKeyTelnyx),
   s3Config
);

// 2. Create Bucket

var createBucketRequest = new PutBucketRequest
{
   BucketName = bucketName
};
var createBucketResponse = await telnyxClient.PutBucketAsync(createBucketRequest);

// 3. Upload object

var putObjectRequest = new PutObjectRequest
{
   BucketName = bucketName,
   Key = "objectName",
   FilePath = "/Users/yiuming/test.txt"
};
// IMPORTANT: chunk encoding is not supported by the Cloud Storage API.
putObjectRequest.UseChunkEncoding = false;
var putObjectResponse = await telnyxClient.PutObjectAsync(putObjectRequest);

// 4. List Objects

var listObjectRequest = new ListObjectsRequest
{
   BucketName = bucketName
};
var listObjectResponse = await telnyxClient.ListObjectsAsync(listObjectRequest);

// 5. List Buckets

var listBucketsRequest = new ListBucketsRequest { };
var listBucketsResponse = await telnyxClient.ListBucketsAsync(listBucketsRequest);

// 6. Download Object

var getObjectRequest = new GetObjectRequest
{
   BucketName = bucketName,
   Key = objectName
};
var getObjectResponse = await telnyxClient.GetObjectAsync(getObjectRequest);

// 7. Presigned URL Get
using (HttpClient client = new HttpClient())
{
   client.BaseAddress = new Uri("https://api.telnyx.com");
   var presignedUrlRequest = new Dictionary
   {
       { "ttl", 200 }
   };
   var presignedUrlRequestJson = JsonSerializer.Serialize(presignedUrlRequest);
   var presignedUrlRequestContent = new StringContent(
       presignedUrlRequestJson,
       Encoding.UTF8,
       "application/json");

   client.DefaultRequestHeaders.Authorization =
       new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", apiKeyTelnyx);
   var presignedUrlResponse =
       await client.PostAsync($"/v2/storage/buckets/{bucketName}/{objectName}/presigned_url",
           presignedUrlRequestContent);
   var content = await presignedUrlResponse.Content.ReadAsStringAsync();
   Console.WriteLine(content);
}

  {:aws, "~> 1.0.0"},
  {:hackney, "~> 1.18"}

telnyx_storage_client =
  AWS.Client.create(
    System.fetch_env!("TELNYX_V2_API_KEY"),
    # secret access key can be left blank for Telnyx Storage
    "",
    System.get_env("TELNYX_STORAGE_REGION", "us-east-1")
  )
  |> AWS.Client.put_endpoint(fn options -> "#{options.region}.telnyxcloudstorage.com" end)

# create a bucket
bucket_name = System.get_env("TELNYX_STORAGE_BUCKET_NAME", "my-test-bucket-#{Enum.random(1..1_000_000)}")

{:ok, _, _} = AWS.S3.create_bucket(telnyx_storage_client, bucket_name, %{})

# write a couple of objects to the bucket
for i <- 1..2 do
  object_key = "object-#{i}.bin"
  # create a blob of random bytes
  upload_request = %{
    "Body" => :rand.bytes(42),
    "ContentType" => "application/octet-stream"
  }

  {:ok, _, _} = AWS.S3.put_object(telnyx_storage_client, bucket_name, object_key, upload_request)
end

# list contents of a bucket
{:ok, %{"ListBucketResult" => bucket_details}, _} = AWS.S3.list_objects(telnyx_storage_client, bucket_name)

# print the object keys
Enum.each(bucket_details["Contents"], fn content ->
  IO.puts("Object key: #{content["Key"]}")
end)

# download the first object
object_key = List.first(bucket_details["Contents"])["Key"]
{:ok, %{"Body" => object_data}, _} = AWS.S3.get_object(telnyx_storage_client, bucket_name, object_key)

IO.puts("Downloaded object data: #{inspect(object_data)}")

  {:req, "~> 0.5"},
  {:jason, "~> 1.4"}

url = "https://api.telnyx.com/v2/storage/buckets/#{bucket_name}/#{object_key}/presigned_url"

api_key = System.fetch_env!("TELNYX_V2_API_KEY")

headers = %{
  "authorization" => "Bearer #{api_key}",
  "content_type" => "application/json",
  "accept" => "application/json"
}

body = %{
  "ttl" => 30
}

{:ok, %{body: %{"data" => %{"presigned_url" => presigned_url}}}} = Req.post(url, headers: headers, json: body)

# download the object using the presigned url
{:ok, %{body: object_data}} = Req.get(presigned_url)

IO.puts("Downloaded object data using presigned URL: #{inspect(object_data)}")

telnyx-edge new-func --language ts --name file-api
cd file-api

[edge_compute]
func_id   = "…"           # filled in by new-func
func_name = "file-api"

[storage.cloudstorage.ASSETS]
bucket_name = "my-assets"   # an existing bucket
region      = "us-east-1"   # us-central-1 | us-east-1 | us-west-1 | eu-central-1 | ap-southeast-1

npm install
telnyx-edge types

// index.ts
import * as http from "node:http";
import { env } from "@telnyx/edge-runtime";

// A small file API backed by a Cloud Storage bucket binding (env.ASSETS):
//   PUT    /files/   store the request body as an object
//   GET    /files/   download an object
//   GET    /files         list objects (optional ?prefix=)
//   DELETE /files/   delete an object
const bucket = env.ASSETS;

function sendJson(res: http.ServerResponse, status: number, body: unknown) {
  res.writeHead(status, { "content-type": "application/json" });
  res.end(JSON.stringify(body));
}

async function readBody(req: http.IncomingMessage): Promise {
  const chunks: Buffer[] = [];
  for await (const chunk of req) chunks.push(chunk as Buffer);
  return Buffer.concat(chunks);
}

const server = http.createServer(async (req, res) => {
  // Health probes must stay unauthenticated
  if (req.url === "/health" || req.url?.startsWith("/health/")) {
    res.writeHead(200);
    res.end();
    return;
  }

  const url = new URL(req.url ?? "/", "http://localhost");
  const isCollection = url.pathname === "/files" || url.pathname === "/files/";
  const key = decodeURIComponent(url.pathname.replace(/^\/files\//, ""));

  try {
    // List: GET /files?prefix=
    if (req.method === "GET" && isCollection) {
      const { objects, truncated, cursor } = await bucket.list({
        prefix: url.searchParams.get("prefix") ?? undefined,
        limit: 100,
      });
      return sendJson(res, 200, {
        objects: objects.map((o) => ({ key: o.key, size: o.size, uploaded: o.uploaded })),
        truncated,
        cursor,
      });
    }

    // Upload: PUT /files/
    if (req.method === "PUT" && key) {
      const body = await readBody(req);
      const put = await bucket.put(key, new Uint8Array(body), {
        httpMetadata: { contentType: req.headers["content-type"] ?? "application/octet-stream" },
      });
      return sendJson(res, 200, { key: put?.key, etag: put?.etag });
    }

    // Download: GET /files/
    if (req.method === "GET" && key) {
      const obj = await bucket.get(key);
      if (obj === null) return sendJson(res, 404, { error: "not found" });
      const bytes = Buffer.from(await obj.arrayBuffer());
      res.writeHead(200, {
        "content-type": obj.httpMetadata?.contentType ?? "application/octet-stream",
        "content-length": String(bytes.byteLength),
      });
      res.end(bytes);
      return;
    }

    // Delete: DELETE /files/  (idempotent)
    if (req.method === "DELETE" && key) {
      await bucket.delete(key);
      res.writeHead(204);
      res.end();
      return;
    }

    sendJson(res, 405, { error: "method not allowed" });
  } catch (err: any) {
    sendJson(res, 500, { error: err?.message ?? "internal error" });
  }
});

server.listen(Number(process.env.PORT ?? 8080), () => console.log("file-api up"));

telnyx-edge ship

telnyx-edge list   # shows STATUS and the INVOKE URL for file-api

# Upload an object
curl -X PUT "$URL/files/hello.txt" -H "content-type: text/plain" --data "hello from the edge"
# → {"key":"hello.txt","etag":"11c9dad6fdb6ae2efe36b9c7aef39031"}

# Download it back
curl "$URL/files/hello.txt"
# → hello from the edge

# List objects
curl "$URL/files"
# → {"objects":[{"key":"hello.txt","size":19,"uploaded":"2026-07-04T…Z"}],"truncated":false}

# Delete it (idempotent — 204 whether or not it existed)
curl -i -X DELETE "$URL/files/hello.txt"
# → HTTP/1.1 204 No Content

interface CloudStorageBucket {
  get(key: string, options?: CloudStorageGetOptions): Promise;
  put(key: string, body: CloudStoragePutBody, options?: CloudStoragePutOptions): Promise;
  head(key: string, options?: CloudStorageOnlyIf): Promise;
  delete(key: string | string[]): Promise;
  list(options?: CloudStorageListOptions): Promise;
  createMultipartUpload(key: string, options?: CloudStoragePutOptions): Promise;
  resumeMultipartUpload(key: string, uploadId: string, options?: CloudStoragePutOptions): CloudStorageMultipartUpload;
}

const obj = await env.MY_BUCKET.get("uploads/logo.png");
if (obj === null) {
  // not found
} else {
  const bytes = await obj.arrayBuffer();   // consume the body once
  // obj.key, obj.size, obj.etag, obj.httpMetadata, obj.customMetadata, …
}

type CloudStorageGetOptions = CloudStorageOnlyIf & {
  range?: CloudStorageRange;
  ssecKey?: ArrayBuffer | string;
};

interface CloudStorageRange {
  offset?: number;   // start byte
  length?: number;   // number of bytes from offset
  suffix?: number;   // final N bytes (mutually exclusive with offset/length)
}

const head = await env.MY_BUCKET.get("videos/clip.mp4", { range: { offset: 0, length: 1024 } });
const tail = await env.MY_BUCKET.get("videos/clip.mp4", { range: { suffix: 512 } });

interface CloudStorageConditional {
  etagMatches?: string;        // read only if the current etag matches      (If-Match)
  etagDoesNotMatch?: string;   // read only if the current etag differs       (If-None-Match)
  uploadedBefore?: Date;       // read only if unchanged since this time      (If-Unmodified-Since)
  uploadedAfter?: Date;        // read only if changed since this time        (If-Modified-Since)
}

interface CloudStorageOnlyIf {
  onlyIf?: CloudStorageConditional | Headers;
}

// Revalidate a cached copy: fetch the body only if the object changed.
const obj = await env.MY_BUCKET.get("data.json", { onlyIf: { etagDoesNotMatch: cachedEtag } });
if (obj !== null && !("body" in obj)) {
  // precondition failed → not modified; keep using the cached copy
} else if (obj) {
  const fresh = await obj.json();
}

type CloudStoragePutBody = ReadableStream | ArrayBuffer | ArrayBufferView | Blob | string;

interface CloudStoragePutOptions {
  httpMetadata?: CloudStorageHTTPMetadata;    // Content-Type, Cache-Control, …
  customMetadata?: Record;    // x-amz-meta-* — keys lower-cased on read
  ssecKey?: ArrayBuffer | string;             // SSE-C key (US and APAC region buckets)
}

await env.MY_BUCKET.put("uploads/logo.png", bytes, {
  httpMetadata: { contentType: "image/png", cacheControl: "max-age=3600" },
  customMetadata: { uploadedby: "alice" },
});

// Strings, ArrayBuffers, typed arrays, Blobs, and streams all work
await env.MY_BUCKET.put("notes/today.txt", "hello world");

const meta = await env.MY_BUCKET.head("uploads/logo.png");
// meta?.size, meta?.uploaded (Date), meta?.version, meta?.httpMetadata, meta?.customMetadata

// Single key
await env.MY_BUCKET.delete("uploads/logo.png");

// Batch — up to 1000 keys per call
await env.MY_BUCKET.delete(["uploads/a.png", "uploads/b.png", "uploads/c.png"]);

interface CloudStorageListOptions {
  prefix?: string;
  limit?: number;
  cursor?: string;    // from a previous result's `cursor`
  delimiter?: string; // roll up keys sharing a prefix into `delimitedPrefixes`
  include?: Array<"httpMetadata" | "customMetadata">; // opt into per-entry metadata
}

interface CloudStorageListResult {
  objects: CloudStorageObject[];
  delimitedPrefixes: string[];   // "folders" — present when `delimiter` is set
  truncated: boolean;
  cursor?: string;               // present when truncated is true
}

let cursor: string | undefined;
do {
  const page = await env.MY_BUCKET.list({ prefix: "uploads/", limit: 100, cursor });
  for (const obj of page.objects) {
    // obj.key, obj.size, obj.etag, …
  }
  cursor = page.truncated ? page.cursor : undefined;
} while (cursor);

const page = await env.MY_BUCKET.list({ prefix: "uploads/", include: ["httpMetadata", "customMetadata"] });
page.objects[0].httpMetadata?.contentType;   // populated because "httpMetadata" was included

const page = await env.MY_BUCKET.list({ prefix: "uploads/", delimiter: "/" });
page.delimitedPrefixes;  // e.g. ["uploads/2026/", "uploads/logos/"] — the "subfolders"
page.objects;            // keys that live directly under "uploads/"

interface CloudStorageMultipartUpload {
  key: string;
  uploadId: string;
  uploadPart(partNumber: number, body: CloudStoragePutBody, options?: CloudStoragePutOptions): Promise;
  complete(parts: CloudStorageUploadedPart[]): Promise;
  abort(): Promise;
}

interface CloudStorageUploadedPart {
  partNumber: number;
  etag: string;
}

const upload = await env.MY_BUCKET.createMultipartUpload("videos/large.mp4", {
  httpMetadata: { contentType: "video/mp4" },
});

const parts: CloudStorageUploadedPart[] = [];
parts.push(await upload.uploadPart(1, firstChunk));   // every part except the last must be ≥ 5 MiB
parts.push(await upload.uploadPart(2, lastChunk));

const object = await upload.complete(parts);          // returns the assembled CloudStorageObject
// object.etag is the multipart form "-", e.g. "…8a0-2"

// Resume an upload started elsewhere, then finish it
const resumed = env.MY_BUCKET.resumeMultipartUpload("videos/large.mp4", uploadId);
parts.push(await resumed.uploadPart(3, moreBytes));
await resumed.complete(parts);

const key = crypto.getRandomValues(new Uint8Array(32)).buffer;   // keep this safe — it's not stored for you

await env.MY_BUCKET.put("secret.bin", bytes, { ssecKey: key });
const obj = await env.MY_BUCKET.get("secret.bin", { ssecKey: key });
// obj?.ssecKeyMd5 identifies the key; reading without the matching key fails

interface CloudStorageObject {
  key: string;
  size?: number;
  etag?: string;                              // unquoted (e.g. "5eb63bbbe0…")
  httpEtag?: string;                          // quoted, header-ready (e.g. "\"5eb63bbbe0…\"")
  uploaded?: Date;
  version?: string;                           // object version id (when bucket versioning is enabled)
  httpMetadata?: CloudStorageHTTPMetadata;
  customMetadata?: Record;    // keys lower-cased on read
  ssecKeyMd5?: string;                        // hex MD5 of the SSE-C key, when the object is SSE-C encrypted
  range?: CloudStorageRange;                  // the requested range, echoed on a ranged get
  writeHttpMetadata(headers: Headers): void;  // copy the stored Content-Type / Cache-Control / … onto a Headers
}

interface CloudStorageObjectBody extends CloudStorageObject {
  body: ReadableStream;
  bodyUsed: boolean;                          // true once the body has been consumed
  arrayBuffer(): Promise;
  text(): Promise;
  json(): Promise;
  blob(): Promise;
}

interface CloudStorageHTTPMetadata {
  contentType?: string;
  cacheControl?: string;
  contentLanguage?: string;
  contentDisposition?: string;
  contentEncoding?: string;
  cacheExpiry?: Date;
}

const obj = await env.MY_BUCKET.get("uploads/logo.png");
if (obj && "body" in obj) {
  const headers = new Headers();
  obj.writeHttpMetadata(headers);            // sets Content-Type, Cache-Control, …
  return new Response(obj.body, { headers });
}

user@localhost ~ % aws s3 cp ~/Projects/s3-test/testdata/10Gfile s3://target-bucket/10Gfile --profile mytelnyxprofile --endpoint-url https://us-west-1.telnyxcloudstorage.com

curl -o my-object.bin https://us-central-1.telnyxcloudstorage.com/my-bucket/my-object.bin\?X-AMZ-Security-Token\=8f0nh1jk8qvf

curl -X PUT -T a-new-object.bin https://us-central-1.telnyxcloudstorage.com/my-bucket/a-new-object.bin\?X-AMZ-Security-Token\=8f0nh1jk8qvf

user@host ~ % aws s3api put-object --body /path/to/file.png --bucket mybestbucket --key objenc --sse-customer-algorithm AES256 --sse-customer-key XXX
{
    "ETag": "\"18830c2cf6204ca111864bf967c40959\"",
    "SSECustomerAlgorithm": "AES256",
    "SSECustomerKeyMD5": "YYY"
}