Go SDK for image and video uploads

client, err := dreep.New(os.Getenv("DREEP_API_KEY"))
if err != nil {
    log.Fatal(err)
}

f, err := os.Open("hero.jpg")
if err != nil {
    log.Fatal(err)
}
defer f.Close()
fi, _ := f.Stat()

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()

asset, err := client.Upload(ctx, dreep.UploadOptions{
    File:        f,
    Filename:    fi.Name(),
    KnownSize:   fi.Size(), // exact Content-Length, no chunked encoding
    Destination: dreep.Destination{Folder: "marketing/2026"},
    Transform:   &dreep.Transform{Width: 1200, Format: dreep.FormatWebP, Quality: 80},
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(asset.URL)
fmt.Println(client.URL(asset.ID, &dreep.Transform{Width: 400})) // no network call

curl -X POST https://api.dreep.cloud/api/v1/upload \
  -H "Authorization: Bearer $DREEP_API_KEY" \
  -F "file=@hero.jpg" \
  -F "folder=marketing/2026" \
  -F "width=1200" \
  -F "format=webp" \
  -F "quality=80"

fi, err := f.Stat()
if err != nil {
    return err
}

asset, err := client.UploadPresigned(ctx, dreep.DirectUploadOptions{
    PresignOptions: dreep.PresignOptions{
        ContentType: "video/mp4",
        SizeBytes:   fi.Size(),
        Filename:    "launch.mp4",
        Destination: dreep.Destination{Folder: "videos/2026"},
        ContentHash: sha256Hex, // optional: skip the PUT for known bytes
    },
    File: f,
})
if err != nil {
    return err
}

clip := client.URL(asset.ID, &dreep.Transform{
    Width:     720,
    Format:    dreep.FormatMP4,
    TrimStart: dreep.Ptr(2.0),
    TrimEnd:   dreep.Ptr(12.0),
})

# Same clip by URL; 202 while processing, then 200 from cache
curl -I "https://cdn.dreep.cloud/api/v1/fetch/<assetId>.mp4?format=mp4&width=720&trimStart=2&trimEnd=12"

type presignRequest struct {
    Filename    string `json:"filename"`
    ContentType string `json:"contentType"`
    SizeBytes   int64  `json:"sizeBytes"`
}

func presignHandler(client *dreep.Client) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Authorise the user and enforce your own quotas first.
        var in presignRequest
        if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
            http.Error(w, "bad request", http.StatusBadRequest)
            return
        }
        upload, err := client.PresignUpload(r.Context(), dreep.PresignOptions{
            Filename:    in.Filename,
            ContentType: in.ContentType,
            SizeBytes:   in.SizeBytes,
            Destination: dreep.Destination{Folder: "user-uploads"},
        })
        if err != nil {
            http.Error(w, "could not start upload", http.StatusBadGateway)
            return
        }
        json.NewEncoder(w).Encode(map[string]string{
            "id":        upload.ID,
            "uploadUrl": upload.UploadURL,
        })
    })
}

func confirmHandler(client *dreep.Client) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        asset, err := client.ConfirmUpload(r.Context(), r.PathValue("id"), nil)
        if err != nil {
            http.Error(w, "could not confirm upload", http.StatusBadGateway)
            return
        }
        json.NewEncoder(w).Encode(asset)
    })
}

mux := http.NewServeMux()
mux.Handle("POST /uploads", presignHandler(client))
mux.Handle("POST /uploads/{id}/confirm", confirmHandler(client))

// Browser: no API key, only the single-use URL
const res = await fetch("/uploads", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ filename: file.name, contentType: file.type, sizeBytes: file.size }),
});
const { id, uploadUrl } = await res.json();

await fetch(uploadUrl, { method: "PUT", body: file, headers: { "Content-Type": file.type } });
await fetch(`/uploads/${id}/confirm`, { method: "POST" });

client, err := dreep.New(
    os.Getenv("DREEP_API_KEY"),
    dreep.WithSigningSecret(os.Getenv("DREEP_SIGNING_SECRET")),
)

card := client.URL(asset.ID, &dreep.Transform{
    Width: 1200, Height: 630, Fit: dreep.FitCover,
    Gravity: dreep.GravityAttention, Format: dreep.FormatAVIF, Quality: 70,
})
// .../fetch/<id>.avif?fit=cover&format=avif&gravity=attention&height=630&quality=70&width=1200

thumb := client.URL(asset.ID, &dreep.Transform{Preset: "thumbnail"}) // ...?p=thumbnail

signed, err := client.SignedURL(asset.ID, 15*time.Minute, nil)
// ...?exp=1774118400&sig=a3f9e2b1...

client, err := dreep.New(os.Getenv("DREEP_API_KEY"),
    dreep.WithMaxRetries(4), // 0 disables retries
    dreep.WithRetryBaseDelay(200*time.Millisecond),
)

asset, err := client.Upload(ctx, opts)
switch {
case err == nil:
    return asset.URL, nil
case dreep.IsPaymentRequired(err):
    if feature, ok := dreep.FeatureLimit(err); ok {
        var e *dreep.Error
        errors.As(err, &e)
        log.Printf("limit hit on %s: used %d of %d", feature, e.Used.Int64(), e.Limit.Int64())
    }
    return "", err // upgrade or buy an add-on; there is no automatic overage
case errors.Is(err, context.DeadlineExceeded):
    return "", fmt.Errorf("upload took too long: %w", err)
default:
    return "", err
}