JSON & blobs, tagged

Tag it. Find it. Skip the schema.

TaglyDB is a JSON and blob storage API built around one idea: most of the data your scripts, pipelines, and workflows produce doesn't need a schema — it needs tags, and a place to put the result. That's it. Store a JSON payload or a blob, attach whatever tags actually describe it, and ask for it back later by exactly the combination that matters. If you've ever reached for Postgres or DynamoDB just to store something you'll only ever look up by two or three attributes, this is the thing you actually wanted.

Get started for freeapi.taglydb.com

api.taglydb.com

Store a tagged result

$ curl -X POST https://api.taglydb.com/items \
     -H "Authorization: Bearer $TAGLYDB_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
          "tags": { "tech": "grpc", "concurrency": "50" },
          "data": { "p50_ms": 12.4, "rps": 4820 }
        }'

Ask for exactly the combination that matters

# every gRPC run at concurrency 50
# repeat a key to OR, mix keys to AND
$ curl "$IDX/items/data?tag=tech=grpc&tag=concurrency=50"

{ "items": [
    { "id": "0199c3f2-4a7e-…",
      "tags": { "tech": "grpc", "concurrency": "50" },
      "data": { "p50_ms": 12.4, "rps": 4820 } }
  ],
  "nextCursor": null }

Built for the runs your ML platform doesn't cover.

MLflow and Weights & Biases proved the pattern: tag a run, filter and compare across thousands of them, always know which one's current. TaglyDB gives you that same model for everything that isn't a training run. Running a benchmark suite across ten frameworks and five concurrency levels? Tag each result with {tech: "grpc", concurrency: "50"} and get instant AND/OR filtering across every dimension — every gRPC run, every run at concurrency 50, or the exact intersection. Hit a network blip mid-benchmark? Skip the key entirely and POST the rerun with the same tags — no collision, and "current" is simply whichever one has the newest timestamp.

The same model covers your automation, too.

A nightly job's output, a CI run's artifacts, a webhook payload waiting on a downstream step — tag it with whatever your pipeline already knows about itself (run id, environment, trigger source) and query it back later without ever having designed a table for it. Your data doesn't stop being useful just because you didn't plan its shape in advance.

Keys when you want them, tags when you don't.

Every index and item can carry an optional key — use one when something needs a stable identity, skip it when tags already do that job. Need to hand a result to something unauthenticated — a dashboard, a teammate, a CDN? Mint a signed, time-limited URL server-side and share it; no embedded credentials, and it expires on its own. Every integration gets its own API key, revocable individually, without touching the others.

Get an API key and store your first tagged object in under a minute.

Get started for free