Multi-cloud Object Storage for AI

Purpose-built storage infrastructure for AI teams and developers. Get high-performance, portable, and cost-effective storage across any cloud.

globally distributed S3-compatible object storage
Trusted by
Fly.io logoPlayground logoFal logoAmplified logoBeam logoQuickwit logoArcjet logoKrea logo
Fly.io logoPlayground logoFal logoAmplified logoBeam logoQuickwit logoArcjet logoKrea logo
Fly.io logoPlayground logoFal logoAmplified logoBeam logoQuickwit logoArcjet logoKrea logo
LogSeam Logoreconfigured logoMappa logoParasail logoHydra logoMyhren ai logoTheb ai logoHumaner Ai logo
LogSeam Logoreconfigured logoMappa logoParasail logoHydra logoMyhren ai logoTheb ai logoHumaner Ai logo
Humaner Ai logoreconfigured logoMappa logoParasail logoHydra logoMyhren ai logoTheb ai logoHumaner Ai logo

Built by the team that built and operate Uber's Storage Platform.

Single Global Endpoint

Migration

Seamless global access to object storage with our single global endpoint.

Migrate
Store Data Near Users

Global Availability

Data stored close to the users automatically ensuring low latency everywhere.

Tigris Architecture
S3 Compatible API

Drop-In Replacement

Global and fast object storage with familiar AWS S3 tools, libraries, and extensions.

Supported SDKs
Fast Small Object Retrieval

99.99% Reliable

Access small objects at close to Redis speed, ensuring swift, efficient retrieval.

Metrics
import { S3Client } from "@aws-sdk/client-s3";
import { Upload } from "@aws-sdk/lib-storage";
import fs from "fs";

const client = new S3Client({
  region: "auto",
  endpoint: "https://fly.storage.tigris.dev",
});

const fileStream = fs.createReadStream("Docker.dmg");
(async () => {
  const upload = new Upload({
    params: {
      Bucket: "foo-bucket",
      Key: "Docker-100.dmg",
      Body: fileStream,
    },
    client: client,
  });

  await upload.done();
})();
require "aws-sdk"

bucket_name = "foo-bucket"

s3 = Aws::S3::Client.new(
    region: "auto",
    endpoint: "https://fly.storage.tigris.dev",
)

# List the first ten objects in the bucket
resp = s3.list_objects(bucket: 'foo-bucket', max_keys: 10)
resp.contents.each do |object|
    puts "#{object.key} => #{object.etag}"
end

# Put an object into the bucket
file_name = "bar-file-#{Time.now.to_i}"
begin
    s3.put_object(
        bucket: bucket_name,
        key: file_name,
        body: File.read("bar.txt")
    )
    puts "Uploaded #{file_name} to #{bucket_name}."
rescue Exception => e
    puts "Failed to upload #{file_name} with error: #{e.message}"
    exit "Please fix error with file upload before continuing."
end
import boto3

# Create S3 service client
svc = boto3.client('s3', endpoint_url='https://fly.storage.tigris.dev')

# List buckets
response = svc.list_buckets()

for bucket in response['Buckets']:
    print(f'  {bucket["Name"]}')

# List objects
response = svc.list_objects_v2(Bucket='foo-bucket')

for obj in response['Contents']:
    print(f'  {obj["Key"]}')

# Upload file
response = svc.upload_file('bar.txt', 'foo-bucket', 'bar.txt')

# Download file
response = svc.download_file('foo-bucket', 'bar.txt', 'bar-downloaded.txt')
package main

import (
	"context"
	"log"
	"os"

	"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() {
	sdkConfig, err := config.LoadDefaultConfig(context.TODO())
	if err != nil {
		log.Printf("Couldn't load default configuration. Here's why: %v\n", err)
		return
	}

	// Create S3 service client
	svc := s3.NewFromConfig(sdkConfig, func(o *s3.Options) {
		o.BaseEndpoint = aws.String("https://fly.storage.tigris.dev")
	})

	file, err := os.Open("bar.txt")
	if err != nil {
		log.Printf("Couldn't open file to upload. Here's why: %v\n", err)
		return
	} else {
		defer file.Close()
		_, err = svc.PutObject(context.TODO(), &s3.PutObjectInput{
			Bucket: aws.String("foo-bucket"),
			Key:    aws.String("bar.txt"),
			Body:   file,
		})
		if err != nil {
			log.Printf("Couldn't upload file. Here's why: %v\n", err)
		}
	}
}

Global Reach, Familiar S3 API

Leverage our S3-compatible API for a seamless transition and enhanced object storage experience

  • Eliminates the complexity of managing data across multiple regions.

  • Ensures your data is available everywhere you need it, without geographical limitations.

  • Seamlessly integrates with existing applications via standard AWS S3 SDKs and libraries.

99.99% Uptime. Backed by public data.

No other storage provider shares its raw reliability data. Tigris publishes the same live metrics we use to calculate our 99.99% uptime—no filters, no spin.

Check It Out on Grafana (LIVE)

Predictable data costs for training and inference

Eliminate data transfer costs across clouds, enabling AI companies to optimize GPU usage and lower their overall operational expenses

Migrating from a S3-compatible bucket

Tigris allows you to transparently migrate the data from an existing S3-compatible storage to Tigris without any downtime and without incurring any egress costs.

Migration Documentation

It's Easy to Get Going

user icon

Sign into your Tigris account

To use Tigris, you need an account. If you don’t already have one, you can create one by signing up via your fly.io account.

Create a bucket

Every object in Tigris is stored in a bucket. Before you can store data in Tigris, you have to create a bucket. Buckets are global and we automatically store the data close to your users. If your users move to a different region, the data moves with them.

Create a bucket
click icon

Start building

Now that you have created a bucket, you are ready to store objects in it. An object can be any kind of file: a text file, a photo, a video and so on. Choose from a wide range of S3 tools, libraries, and extensions.

SDK Docs
Start building

Usage in Numbers.

10PB+
of storage
5B+
objects
500M+
requests per day
15K+
buckets

Knowledge Hub

How does Tigris ensure data accessibility around the world?

In Tigris, buckets are inherently global entities. This means that the objects within your bucket are stored in the region where the initial requests are made. To optimize performance and reduce latency, these objects are intelligently distributed to other regions based on the access patterns observed over time.

Tell me more about the S3-compatible API. How does it work?

Tigris is compatible with the AWS S3 API. This means that you can use the standard AWS S3 SDKs, tool and libraries with Tigris. See the S3 API Compatibility section in our docs for more details. We also have language specific guides on how to use the AWS S3 SDKs with Tigris.

How do I signup and get access to Tigris?

Simply sign up through the web console or CLI. See the Getting Started section in our docs for more details.

What is Tigris pricing like?

Tigris pricing is designed so that you only pay for what you use. The pricing is based on the amount of data stored, and the number of requests made. We don't charge for regional data transfer, region-to-region data transfer, or data transfer out to the internet (egress). You can read more about our pricing and free allowance in the Pricing guide.

Ready to embark on your journey with Tigris?

Get started