# Strovio documentation (full)

Every page of the Strovio docs, use cases and comparisons in one file. Index: https://strovio.xyz/llms.txt

---

URL: https://strovio.xyz/docs
Markdown: https://strovio.xyz/docs.md

# Strovio docs

Strovio is file storage for developers and their AI agents. You upload a file, choose whether it is public or private, and get a link: a permanent URL for public files, or a signed URL that expires after one hour for private files. You can also create share links from the dashboard.

You can use Strovio four ways:

- The web dashboard at [strovio.xyz](https://strovio.xyz), for people.
- The REST API at `https://strovio.xyz/api/v1`, with an API key.
- The TypeScript SDK, `strovio-sdk`, for Node.js 18 or later.
- The MCP server, `strovio-mcp`, so Claude, Cursor, Codex and other MCP clients can manage files.

## Quick start

1. A person signs up at [strovio.xyz/signup](https://strovio.xyz/signup). The 14-day trial needs no card.
2. They open [strovio.xyz/developer](https://strovio.xyz/developer), create an API key and copy it. It starts with `sk_live_` and is shown once.
3. Upload a file:

```bash
export STROVIO_API_KEY="sk_live_..."
curl -X PUT "https://strovio.xyz/api/v1/files/notes/hello.txt" \
  -H "Authorization: Bearer $STROVIO_API_KEY" \
  -H "Content-Type: text/plain" \
  -H "X-Access: private" \
  --data-binary @hello.txt
```

The response is `201` with the stored `key`. Then `GET https://strovio.xyz/api/v1/files/notes/hello.txt` returns a download `url`.

## Guides

- [Build with AI agents](https://strovio.xyz/docs/agents): every entry point for agents, and a snippet for your own AGENTS.md.
- [Create an account and an API key](https://strovio.xyz/docs/get-an-api-key)
- [Upload, list, download and delete files](https://strovio.xyz/docs/upload-and-download) with curl on macOS, Linux and Windows.
- [Upload large files](https://strovio.xyz/docs/large-uploads) with multipart uploads.
- [Share a file with a link](https://strovio.xyz/docs/share-links)
- [Connect an AI agent with MCP](https://strovio.xyz/docs/mcp): Claude Code, Claude Desktop, Cursor and Codex.

## Reference

- [REST API](https://strovio.xyz/docs/api) and the [OpenAPI document](https://strovio.xyz/openapi.json)
- [TypeScript SDK](https://strovio.xyz/docs/sdk)
- [Errors](https://strovio.xyz/docs/errors)

## Plans

| | Trial | Pro | Team |
|---|---|---|---|
| Price | Free for 14 days | $10 a month | $28 a month |
| Storage | 2 GB | 25 GB | 100 GB |
| API keys | 1 | 5 | Unlimited |
| Share links | 10 | Unlimited | Unlimited |
| Team members | 1 | 1 | 5 |
| Largest file | 512 MB | 512 MB | 512 MB |

Upgrade from [strovio.xyz/billing](https://strovio.xyz/billing) after signing in. Questions: support@strovio.xyz.

Every docs page is also available as Markdown: add `.md` to its URL, for example [strovio.xyz/docs.md](https://strovio.xyz/docs.md).

---

URL: https://strovio.xyz/docs/agents
Markdown: https://strovio.xyz/docs/agents.md

# Build with AI agents

Strovio is built to be used by AI agents as well as people. This page lists every entry point. The REST API and the files for agents work today. The MCP server and the SDK work once their npm packages are published; check with the commands below.

## Files for agents

- [llms.txt](https://strovio.xyz/llms.txt): a short map of Strovio with instructions for agents.
- [llms-full.txt](https://strovio.xyz/llms-full.txt): every docs page in one Markdown file.
- Markdown pages: add `.md` to any docs URL, for example [strovio.xyz/docs/mcp.md](https://strovio.xyz/docs/mcp.md). Each HTML page also links its Markdown version with `<link rel="alternate" type="text/markdown">`.
- [OpenAPI document](https://strovio.xyz/openapi.json) for the REST API.

## Ways to act

| Entry point | Use it when | Auth |
|---|---|---|
| [MCP server](https://strovio.xyz/docs/mcp) `strovio-mcp` | Your agent runs on a computer with Node.js 18+ and supports local (stdio) MCP servers: Claude Code, Claude Desktop, Cursor, Codex | `STROVIO_API_KEY` environment variable |
| [REST API](https://strovio.xyz/docs/api) | Your agent can run `curl` or make HTTP requests, including from Windows, Linux containers and CI | `Authorization: Bearer sk_live_...` |
| [TypeScript SDK](https://strovio.xyz/docs/sdk) `strovio-sdk` | You are writing Node.js code | `STROVIO_API_KEY` environment variable or the `apiKey` option |

Before installing a package, check it is published and find the latest version:

```bash
npm view strovio-mcp version
npm view strovio-sdk version
```

If either command returns `404 Not Found`, that package is not published yet. Use the REST API instead; it supports every file operation the packages do.

There is no hosted (remote) MCP server and no command-line tool yet. Agents without a local shell, such as ChatGPT in a browser, cannot call Strovio directly today.

## Access

An API key belongs to a person's Strovio account. A person signs up at [strovio.xyz/signup](https://strovio.xyz/signup) and creates the key at [strovio.xyz/developer](https://strovio.xyz/developer). An agent cannot create a key without signing in as that person. See [Create an account and an API key](https://strovio.xyz/docs/get-an-api-key).

## Trying things safely

Strovio has no sandbox or test mode. To try it safely:

- Check the service without a key: `curl https://strovio.xyz/api/health` returns `{"ok":true,...}`, and `curl https://strovio.xyz/api/v1/files` returns `401` with code `invalid_api_key`.
- With a key, listing and getting files never change anything.
- Put test uploads under their own path such as `agent-test/`, keep them private, and delete them when you are done. Test files count towards the account's storage until deleted.

## Rules for agents

- Keep the API key in an environment variable or the MCP client's `env` block. Never commit it, paste it into a public file, or print it in logs. Every key has full access to the account's files, including deleting them.
- Uploading to an existing path with the same access replaces that file. Check with `file_exists` or `HEAD` first if that matters. Uploading the same path with the other access creates a second file, and path-only requests then return `409 ambiguous_key`.
- Deleting is permanent. Only delete files the person asked you to delete or that you created.
- Make a file public only when the person asks. Public URLs work for anyone who has them and do not expire.
- Do not sign up, sign in, or upgrade a plan on someone's behalf without their explicit go-ahead.

## Snippet for your AGENTS.md

Paste this into your own repository's `AGENTS.md`, `CLAUDE.md` or Cursor rules:

```markdown
## File storage (Strovio)

- Docs for agents: https://strovio.xyz/llms.txt (add .md to any https://strovio.xyz/docs URL for Markdown).
- Auth: STROVIO_API_KEY (sk_live_...) from the environment. Never commit it.
- Upload: PUT https://strovio.xyz/api/v1/files/<path> with Authorization: Bearer $STROVIO_API_KEY, Content-Type and X-Access: public|private.
- Get a download URL: GET https://strovio.xyz/api/v1/files/<path>. Private URLs expire after 1 hour.
- List: GET https://strovio.xyz/api/v1/files?prefix=<text>&limit=<1-1000>. Delete: DELETE https://strovio.xyz/api/v1/files/<path>.
- Errors return JSON with error, code and doc_url. Read doc_url before retrying. Retry 5xx with backoff; fix the request for 4xx.
- Uploading to an existing path with the same access replaces it. Deleting is permanent.
```

---

URL: https://strovio.xyz/docs/get-an-api-key
Markdown: https://strovio.xyz/docs/get-an-api-key.md

# Create an account and an API key

A person does these steps in a web browser. An agent should ask the person to do them and to put the key in an environment variable, rather than signing up or signing in for them.

## Prerequisites

- An email address.
- A web browser on any operating system.

## 1. Sign up

1. Open [strovio.xyz/signup](https://strovio.xyz/signup).
2. Enter a name, an email address and a password of at least 8 characters, then choose to create the account.
3. Expected result: you land on the dashboard at `strovio.xyz/dashboard`, on a 14-day free trial. No card is needed.

If the email is already registered, sign in at [strovio.xyz/login](https://strovio.xyz/login) instead. Forgot the password: [strovio.xyz/forgot-password](https://strovio.xyz/forgot-password).

## 2. Create an API key

1. Open [strovio.xyz/developer](https://strovio.xyz/developer) (Developer in the dashboard sidebar).
2. Create a new key and give it a name that says where it will be used, for example `laptop-claude-code`.
3. Copy the key. It starts with `sk_live_` and is shown only once.

Expected result: the key appears in the list with its first characters and a last-used time. Every key has full access to the account's files, including deleting them; there are no read-only keys yet.

The trial allows 1 key, Pro 5 and Team unlimited. If creation fails with "API key limit reached for your plan", delete an unused key on the same page or upgrade at [strovio.xyz/billing](https://strovio.xyz/billing).

## 3. Store the key

Keep it in an environment variable called `STROVIO_API_KEY`. The MCP server and the SDK read that name.

macOS and Linux (bash or zsh), for the current terminal:

```bash
export STROVIO_API_KEY="sk_live_..."
```

To keep it, add the same line to `~/.zshrc` (macOS default) or `~/.bashrc`.

Windows PowerShell, for the current window:

```powershell
$env:STROVIO_API_KEY = "sk_live_..."
```

To keep it for your Windows user, run `setx STROVIO_API_KEY "sk_live_..."` and open a new terminal.

## 4. Confirm it works

macOS and Linux:

```bash
curl -s "https://strovio.xyz/api/v1/files?limit=1" -H "Authorization: Bearer $STROVIO_API_KEY"
```

Windows PowerShell (use `curl.exe`, because `curl` is an alias for a different command in Windows PowerShell 5.1):

```powershell
curl.exe -s "https://strovio.xyz/api/v1/files?limit=1" -H "Authorization: Bearer $env:STROVIO_API_KEY"
```

Expected result: `{"objects":[],"count":0}` on a new account, or your newest file.

## Common errors

- `401` with code `invalid_api_key`: the key is missing, mistyped or deleted. Check that the variable is set in this terminal (`echo $STROVIO_API_KEY` or `echo $env:STROVIO_API_KEY`) and that the header is exactly `Authorization: Bearer sk_live_...`. Create a new key if the old one was deleted.
- The key was lost: keys are stored hashed and cannot be shown again. Create a new one and delete the old one.

## Revoke a key

Delete it on [strovio.xyz/developer](https://strovio.xyz/developer). Requests with that key fail with `401` straight away.

---

URL: https://strovio.xyz/docs/upload-and-download
Markdown: https://strovio.xyz/docs/upload-and-download.md

# Upload, list, download and delete files

This guide uses `curl` and the REST API, which works from any operating system, container or CI job. The [MCP server](https://strovio.xyz/docs/mcp) and the [SDK](https://strovio.xyz/docs/sdk) do the same things.

## Prerequisites

- An API key in `STROVIO_API_KEY`. See [Create an account and an API key](https://strovio.xyz/docs/get-an-api-key).
- `curl`. It ships with macOS, most Linux distributions and Windows 10 and 11 (as `curl.exe`).

On Windows PowerShell, write `curl.exe` instead of `curl` and `$env:STROVIO_API_KEY` instead of `$STROVIO_API_KEY`, and put each command on one line.

## Paths and keys

You choose a path when you upload, such as `reports/2026/q1.pdf`. Letters, numbers, dots, dashes, underscores and `/` are safest; percent-encode anything else in the URL, for example a space as `%20`. Do not start with `/` and do not use `..`.

Strovio stores the file under a full key: `uploads/<your account id>/<public or private>/<your path>`. Responses return that full key. To get, check or delete a file, send either the full key or exactly the path you uploaded to. If the same path exists as both a public and a private file, the path alone returns `409 ambiguous_key`; send the full key instead.

## 1. Upload

```bash
curl -X PUT "https://strovio.xyz/api/v1/files/reports/q1.pdf" \
  -H "Authorization: Bearer $STROVIO_API_KEY" \
  -H "Content-Type: application/pdf" \
  -H "X-Access: private" \
  --data-binary @q1.pdf
```

Windows PowerShell:

```powershell
curl.exe -X PUT "https://strovio.xyz/api/v1/files/reports/q1.pdf" -H "Authorization: Bearer $env:STROVIO_API_KEY" -H "Content-Type: application/pdf" -H "X-Access: private" --data-binary "@q1.pdf"
```

- `X-Access: public` gives the file a permanent public URL. Anything else, or no header, makes it private.
- Always set `Content-Type` to the file's media type. It is stored and returned when the file is downloaded. Without it, curl sends `application/x-www-form-urlencoded` and that is what gets stored.
- Uploading to a path that already exists with the same access replaces the file. Uploading it with the other access creates a second file at the same path; path-only requests then return `409 ambiguous_key`, so use the full key.

Expected result: status `201` and JSON like:

```json
{
  "key": "uploads/clx.../private/reports/q1.pdf",
  "name": "reports/q1.pdf",
  "size": 204800,
  "contentType": "application/pdf",
  "access": "private",
  "url": null,
  "createdAt": "2026-11-07T10:15:30.250Z"
}
```

For public files `url` is the permanent public URL. For files over about 100 MB, use [multipart uploads](https://strovio.xyz/docs/large-uploads); the limit for a single request is 512 MB.

## 2. List

```bash
curl "https://strovio.xyz/api/v1/files?prefix=reports/&limit=50" \
  -H "Authorization: Bearer $STROVIO_API_KEY"
```

- `prefix` returns only files whose key contains that text anywhere, so `reports/` also matches `old/reports/q1.pdf`. Check the `key` of each result before acting on it.
- `limit` is a whole number from 1. Values above 1000 are treated as 1000, which is also the default.
- Files come newest first in `objects`, with `count`.

## 3. Get a download URL

```bash
curl "https://strovio.xyz/api/v1/files/reports/q1.pdf" \
  -H "Authorization: Bearer $STROVIO_API_KEY"
```

Expected result: status `200` and JSON like:

```json
{
  "key": "uploads/clx.../private/reports/q1.pdf",
  "name": "q1.pdf",
  "size": 204800,
  "contentType": "application/pdf",
  "access": "private",
  "url": "https://s3.strovio.xyz/...&X-Amz-Expires=3600&...",
  "expiresIn": 3600,
  "createdAt": "2026-11-07T10:15:30.250Z",
  "updatedAt": "2026-11-07T10:15:30.250Z"
}
```

- Public files: `url` is the permanent public URL, and `expiresIn` is `null`.
- Private files: `url` is a signed URL valid for 3600 seconds (one hour), and `expiresIn` is `3600`. The lifetime is fixed; request a new URL when it expires. For a link that never expires, a person creates a [share link](https://strovio.xyz/docs/share-links).

Download it (`-f` makes curl fail instead of saving an error page if the URL has expired):

```bash
curl -fL -o q1.pdf "<url from the response>"
```

## 4. Check whether a file exists

```bash
curl -I "https://strovio.xyz/api/v1/files/reports/q1.pdf" \
  -H "Authorization: Bearer $STROVIO_API_KEY"
```

`200` means it exists, with `Content-Length`, `Content-Type`, `X-Access` and `Last-Modified` headers. `404` means it does not.

## 5. Delete

```bash
curl -X DELETE "https://strovio.xyz/api/v1/files/reports/q1.pdf" \
  -H "Authorization: Bearer $STROVIO_API_KEY"
```

Expected result: `{"ok":true,"key":"uploads/.../private/reports/q1.pdf"}`. Deleting is permanent and also removes the file's share links. Files deleted through the API do not go to the dashboard trash.

## The same steps in Windows PowerShell

```powershell
curl.exe "https://strovio.xyz/api/v1/files?prefix=reports/&limit=50" -H "Authorization: Bearer $env:STROVIO_API_KEY"
curl.exe "https://strovio.xyz/api/v1/files/reports/q1.pdf" -H "Authorization: Bearer $env:STROVIO_API_KEY"
curl.exe -fL -o q1.pdf "<url from the response>"
curl.exe -I "https://strovio.xyz/api/v1/files/reports/q1.pdf" -H "Authorization: Bearer $env:STROVIO_API_KEY"
curl.exe -X DELETE "https://strovio.xyz/api/v1/files/reports/q1.pdf" -H "Authorization: Bearer $env:STROVIO_API_KEY"
```

## Confirm success

Run step 4 for the path. After an upload it returns `200`; after a delete it returns `404`.

## Common errors

- `401 invalid_api_key`: see [Create an account and an API key](https://strovio.xyz/docs/get-an-api-key).
- `404 file_not_found`: the path or key does not match a file. List with `prefix` to find the exact key.
- `409 ambiguous_key`: a public and a private file share the path. Use the full key.
- `413 file_too_large`: the body is over 512 MB.
- `413 storage_quota_exceeded`: delete files or upgrade at [strovio.xyz/billing](https://strovio.xyz/billing).
- On Windows, `Invoke-WebRequest : A parameter cannot be found`: you ran `curl` instead of `curl.exe`.

All codes are listed on [Errors](https://strovio.xyz/docs/errors).

---

URL: https://strovio.xyz/docs/large-uploads
Markdown: https://strovio.xyz/docs/large-uploads.md

# Upload large files

A multipart upload sends a file in parts straight to storage, so no single request has to carry the whole file. A single `PUT` works up to 512 MB, but use multipart for files over about 100 MB, on slow or unreliable connections, or whenever a proxy in your network rejects large requests. The maximum file size is 512 MB (536,870,912 bytes) either way.

The [SDK](https://strovio.xyz/docs/sdk) uses multipart automatically for uploads between 1 MiB and its 50 MiB limit. For anything larger, use the script below or the raw steps after it.

## Prerequisites

- An API key in `STROVIO_API_KEY`.
- Node.js 18 or later for the script, on macOS, Windows or Linux.

## Upload with a script (any platform)

Save this as `upload-large.mjs`:

```js
import { open, stat } from "node:fs/promises";

const [file, key, contentType = "application/octet-stream", access = "private"] = process.argv.slice(2);
if (!process.env.STROVIO_API_KEY) throw new Error("Set STROVIO_API_KEY first: https://strovio.xyz/docs/get-an-api-key");
if (!file || !key) throw new Error("Usage: node upload-large.mjs <file> <key> [contentType] [public|private]");
const api = "https://strovio.xyz/api/v1";
const auth = { Authorization: `Bearer ${process.env.STROVIO_API_KEY}` };

async function post(path, body) {
  const res = await fetch(`${api}${path}`, {
    method: "POST",
    headers: { ...auth, "Content-Type": "application/json" },
    body: JSON.stringify(body),
  });
  const text = await res.text();
  if (!res.ok) throw new Error(`${path} failed with status ${res.status}: ${text}`);
  return JSON.parse(text);
}

const { size } = await stat(file);
const start = await post("/files/multipart/start", { key, size, contentType, access });
const handle = await open(file);
const parts = [];
let offset = 0;
for (const part of start.parts) {
  const chunk = Buffer.alloc(part.contentLength);
  await handle.read(chunk, 0, part.contentLength, offset);
  offset += part.contentLength;
  const res = await fetch(part.url, { method: "PUT", body: chunk });
  if (!res.ok) throw new Error(`Part ${part.partNumber} failed with status ${res.status}`);
  parts.push({ PartNumber: part.partNumber, ETag: res.headers.get("etag") });
  console.error(`Uploaded part ${part.partNumber} of ${start.parts.length}`);
}
await handle.close();
console.log(await post("/files/multipart/complete", { s3Key: start.s3Key, uploadId: start.uploadId, key, contentType, access, parts }));
```

Run it:

```bash
node upload-large.mjs video.mp4 videos/demo.mp4 video/mp4 private
```

Expected result: a progress line per part, then the file object with `"access": "private"` and the full `size`.

## The raw steps

### 1. Start

```bash
curl -X POST "https://strovio.xyz/api/v1/files/multipart/start" \
  -H "Authorization: Bearer $STROVIO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"key":"videos/demo.mp4","contentType":"video/mp4","size":134217728,"access":"private"}'
```

Expected result: `uploadId`, `s3Key`, `bucket` and a `parts` list. Each part has a `partNumber`, a signed `url` and a `contentLength`. Use each part's `contentLength` rather than assuming a size: today every part is 5 MiB (5242880 bytes) except the last, which holds the remainder.

### 2. Upload each part

`PUT` bytes `[offset, offset + contentLength)` of the file to each part's `url`, and keep the `ETag` response header of each, quotes included. On macOS or Linux, for part `n` (counting from 1) with 5 MiB parts:

```bash
dd if=video.mp4 of=part.bin bs=5242880 skip=$((n - 1)) count=1 2>/dev/null
curl -sf -D - -o /dev/null -X PUT -H "Content-Type:" --data-binary @part.bin "<parts[n-1].url>" \
  | grep -i '^etag:' | cut -d' ' -f2 | tr -d '\r'
```

The last command prints the ETag, for example `"9b2cf535f27731c974343645a3985328"`. `-H "Content-Type:"` stops curl adding a form content type. On Windows, use the script above. Parts can be sent one at a time or in parallel. Do not send an `Authorization` header to the part URLs; they are already signed. Part URLs stay valid for two hours.

### 3. Complete

```bash
curl -X POST "https://strovio.xyz/api/v1/files/multipart/complete" \
  -H "Authorization: Bearer $STROVIO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"s3Key":"<s3Key>","uploadId":"<uploadId>","key":"videos/demo.mp4","contentType":"video/mp4","access":"private","parts":[{"PartNumber":1,"ETag":"\"<etag 1>\""},{"PartNumber":2,"ETag":"\"<etag 2>\""}]}'
```

Note the field names: start returns `partNumber`, while complete takes `PartNumber` and `ETag`. Send the same `key` and `access` as in step 1.

Expected result: `201` with the same fields as a normal upload.

There is no abort call. An upload that is never completed does not create a file.

## Confirm success

`curl -I https://strovio.xyz/api/v1/files/videos/demo.mp4 -H "Authorization: Bearer $STROVIO_API_KEY"` returns `200` and the full `Content-Length`.

## Common errors

- `400 invalid_request` with "s3Key does not match key and access": send the same `key` and `access` you sent to start.
- `403 forbidden`: the `s3Key` came from a different account's upload. Use the `s3Key` from your own start call.
- `413 file_too_large` or `storage_quota_exceeded`: the file is over 512 MB or your storage is full.
- A part `PUT` returns `403`: the part URL expired. Start again.
- `500 internal_error` on complete, often an ETag that does not match: start again and copy the ETags exactly.

## Small files without multipart

For a single signed upload, call `POST /api/v1/files/presign-put` with `key`, `contentType`, `size` and `access`, `PUT` the bytes to the returned `putUrl` with the same `Content-Type` within one hour, then call `POST /api/v1/files/complete` with `key`, `contentType` and `access`. See the [API reference](https://strovio.xyz/docs/api).

---

URL: https://strovio.xyz/docs/share-links
Markdown: https://strovio.xyz/docs/share-links.md

# Share a file with a link

There are three ways to give someone a file:

| Link | Lasts | Who can create it |
|---|---|---|
| Public URL (upload with `X-Access: public`) | Until the file is deleted | API, SDK, MCP or dashboard |
| Signed URL from `GET /api/v1/files/<path>` for a private file | One hour | API, SDK, MCP |
| Share link `https://strovio.xyz/share/<token>` | Until revoked, or until the file is trashed or deleted | Dashboard only |

## Create a share link (person, in the dashboard)

1. Sign in and open the file in the dashboard.
2. Choose Share and create a link.
3. Copy the `https://strovio.xyz/share/<token>` URL.

Share links cannot be created with an API key today. An agent can create a public URL or a one-hour signed URL instead.

The trial allows 10 share links; Pro and Team are unlimited.

## Download a shared file (anyone)

A request whose `Accept` header includes `text/html` (a browser) gets a page with a download button. Any other request, such as curl, `fetch` or `Invoke-WebRequest`, is redirected to a signed download URL for the file. From a terminal:

```bash
curl -fL -OJ "https://strovio.xyz/share/<token>"
```

`-f` stops curl saving an error message as the file; `-OJ` saves it under its original name.

On Windows PowerShell use `curl.exe` with the same arguments. Adding `?download=1` to the link forces a download in a browser too.

## Common errors

- `404` "Link not found or has been revoked.": ask the owner for a new link.
- `410` "The owner moved this file to their trash." or "The file behind this link no longer exists.": the owner must restore or upload the file again.
- `502` "Storage is not responding right now.": try again in a minute.

## Revoke a share link

The owner revokes it from the file's Share panel in the dashboard. Deleting the file also removes its share links.

---

URL: https://strovio.xyz/docs/mcp
Markdown: https://strovio.xyz/docs/mcp.md

# Connect an AI agent with MCP

The Strovio MCP server, `strovio-mcp`, lets an MCP client list, upload, inspect and delete your Strovio files. It runs on your computer over stdio, started by the client with `npx`, and talks to `https://strovio.xyz` with your API key.

## Prerequisites

- Node.js 18 or later: `node --version`. Install from [nodejs.org](https://nodejs.org) if missing.
- A Strovio API key. See [Create an account and an API key](https://strovio.xyz/docs/get-an-api-key).
- The package is published: `npm view strovio-mcp version` prints a version. If it prints `404 Not Found`, the package is not published yet; use the [REST API](https://strovio.xyz/docs/upload-and-download) instead.

## Environment

| Variable | Required | Value |
|---|---|---|
| `STROVIO_API_KEY` | Yes | Your `sk_live_...` key |
| `STROVIO_API_URL` | No | Defaults to `https://strovio.xyz`. Origin only, no `/api/v1`. |

Every client below stores the key in plain text in its own config file (Claude Code in `~/.claude.json`, the others in the files named in their sections). Keep those files out of version control and readable only by you.

## Claude Code

With the key already in `STROVIO_API_KEY` (so it does not land in your shell history), on macOS and Linux:

```bash
claude mcp add -s user strovio -e STROVIO_API_KEY="$STROVIO_API_KEY" -- npx -y strovio-mcp
```

Windows (native, not WSL), where `npx` must run through `cmd /c`:

```powershell
claude mcp add -s user strovio -e STROVIO_API_KEY=$env:STROVIO_API_KEY -- cmd /c npx -y strovio-mcp
```

`-s user` makes it available in every project; leave it out to add it to the current project only. Options go before `--`. Check with `claude mcp list`; `strovio` should show as connected.

## Claude Desktop

Open Settings, then Developer, then Edit Config. On Windows, use `"command": "cmd"` and `"args": ["/c", "npx", "-y", "strovio-mcp"]` if the server fails to start. The file is `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS and `%APPDATA%\Claude\claude_desktop_config.json` on Windows. Add:

```json
{
  "mcpServers": {
    "strovio": {
      "command": "npx",
      "args": ["-y", "strovio-mcp"],
      "env": { "STROVIO_API_KEY": "sk_live_..." }
    }
  }
}
```

Restart Claude Desktop. The Strovio tools appear in the tools menu.

## Cursor

Put the same `mcpServers` block in `~/.cursor/mcp.json` for every project, or `.cursor/mcp.json` in one project. Do not commit a file that contains the key. Open Cursor Settings, then MCP, and check that `strovio` is enabled with five tools.

## Codex

From a terminal on macOS or Linux:

```bash
codex mcp add strovio --env STROVIO_API_KEY="$STROVIO_API_KEY" -- npx -y strovio-mcp
```

On Windows, in PowerShell:

```powershell
codex mcp add strovio --env STROVIO_API_KEY=$env:STROVIO_API_KEY -- cmd /c npx -y strovio-mcp
```

Or add to `~/.codex/config.toml` (on Windows, `%USERPROFILE%\.codex\config.toml`):

```toml
[mcp_servers.strovio]
command = "npx"
args = ["-y", "strovio-mcp"]
env = { STROVIO_API_KEY = "sk_live_..." }
```

On Windows, use `command = "cmd"` and `args = ["/c", "npx", "-y", "strovio-mcp"]`. Start a new Codex session and run `/mcp`; `strovio` should list five tools.

## Other MCP clients

Any client that can start a stdio server works. Command `npx`, arguments `-y strovio-mcp`, environment `STROVIO_API_KEY`.

## Tools

| Tool | Use it to | Arguments |
|---|---|---|
| `list_files` | Find files and their exact keys, newest first | `prefix` (optional text the key contains anywhere, so `reports/` also matches `old/reports/`), `limit` (optional, 1 to 100) |
| `upload_file` | Upload a file from the computer running the server, up to 50 MiB. Replaces a file at the same key. | `filePath` (required), `key` (required, for example `reports/q1.pdf`), `access` (`public` or `private`, default `private`) |
| `get_file` | Get details and a download URL. Private URLs last one hour. | `key` (required) |
| `file_exists` | Check whether a file exists without downloading it | `key` (required) |
| `delete_file` | Permanently delete a file | `key` (required) |

Every tool returns JSON as text. Errors return `isError: true` with a message, the error code and a link to its fix.

`upload_file` reads `filePath` on the machine where the MCP server runs, so it suits local agents. The content type is set from the file extension.

## Try it

Ask your agent: "List my Strovio files." Then: "Upload ./notes.txt to Strovio as agent-test/notes.txt, private, and give me a download link." Then: "Delete agent-test/notes.txt from Strovio."

## Common errors

- The server does not start, and its log says "API key is required": `STROVIO_API_KEY` is not in the server's `env` block. Clients do not pass your shell's variables to MCP servers unless configured to.
- `Invalid or missing API key (invalid_api_key ...)`: the key is mistyped or was deleted. Create a new one at [strovio.xyz/developer](https://strovio.xyz/developer).
- `npm error 404 Not Found - GET https://registry.npmjs.org/strovio-mcp`: the package is not published yet. Use the REST API.
- `spawn npx ENOENT` or "command not found": Node.js is not installed or not on the client's `PATH`. Install Node.js 18+, restart the client, and on Windows use the `cmd /c` form.
- `Upload body cannot be larger than 50 MiB through the SDK`: use a [multipart upload](https://strovio.xyz/docs/large-uploads) with the REST API.
- `List limit must be an integer from 1 to 100`: pass a smaller `limit`.

## Hosted MCP

There is no hosted (remote) Strovio MCP server yet, so browser-based agents such as ChatGPT cannot connect. Use the REST API from any agent that can make HTTP requests.

---

URL: https://strovio.xyz/docs/sdk
Markdown: https://strovio.xyz/docs/sdk.md

# TypeScript SDK

`strovio-sdk` is a typed client for the Strovio REST API. It runs in Node.js 18 or later (it uses `fetch` and `Buffer`) and ships CommonJS, ES module and type definitions.

## Install

Check that it is published and see the latest version:

```bash
npm view strovio-sdk version
```

If that prints `404 Not Found`, the SDK is not published yet; use the [REST API](https://strovio.xyz/docs/api). Otherwise:

```bash
npm install strovio-sdk
```

## Configure

```ts
import { StrovioClient } from "strovio-sdk";

const strovio = new StrovioClient();
```

With no options the client reads `STROVIO_API_KEY` and `STROVIO_API_URL` from the environment. `STROVIO_API_URL` defaults to `https://strovio.xyz`. You can pass them instead:

```ts
const strovio = new StrovioClient({
  apiKey: process.env.MY_STROVIO_KEY,
  apiUrl: "https://strovio.xyz",
  timeoutMs: 30000,
});
```

`apiUrl` must use `https://` unless it points at `localhost`. `timeoutMs` is per request, from 1 to 120000, default 30000. A missing key throws a `StrovioError` with status 401 that says where to create one.

## Upload

```ts
import { readFile } from "node:fs/promises";

const file = await strovio.upload("reports/q1.pdf", await readFile("q1.pdf"), {
  contentType: "application/pdf",
  access: "private",
});
console.log(file.key, file.url);
```

- `key` is the path to store under. No leading `/`, no `..`, no empty segments.
- `body` is a `Buffer`, `Uint8Array`, `Blob` or `ReadableStream`, up to 50 MiB. The SDK reads the whole body into memory first. For larger files use the script in [Upload large files](https://strovio.xyz/docs/large-uploads).
- `access` is `"public"` or `"private"` (default `"private"`). `contentType` defaults to `application/octet-stream`.
- Bodies over 1 MiB are sent as a multipart upload automatically.
- Returns `{ key, name, size, contentType, access, url, createdAt }`. `url` is the permanent public URL for public files and `null` for private files.

`UploadOptions` also accepts `idempotencyKey`, `metadata` and `expectedOwnerId`. They are sent as headers but the API does not use them today. Retrying an upload to the same key and access replaces the same file, so retries do not create duplicates.

## List

```ts
const { objects, count } = await strovio.list({ prefix: "reports/", limit: 50 });
```

`prefix` matches keys that contain the text anywhere, so `reports/` also matches `old/reports/`. `limit` is 1 to 100 in the SDK. Files come newest first.

## Get a download URL

```ts
const detail = await strovio.get("reports/q1.pdf");
console.log(detail.url, detail.expiresIn);
```

Private files return a signed URL valid for 3600 seconds (`expiresIn: 3600`). Public files return their permanent URL (`expiresIn: null`).

## Check and delete

```ts
const { exists, size } = await strovio.exists("reports/q1.pdf");
await strovio.delete("reports/q1.pdf");
```

`exists` sends a `HEAD` request and returns `{ exists: false }` for a missing file. `delete` returns `{ ok: true, key }` and is permanent.

## Errors

Every failure throws `StrovioError`:

```ts
import { StrovioError } from "strovio-sdk";

try {
  await strovio.get("missing.txt");
} catch (err) {
  if (err instanceof StrovioError) {
    console.log(err.statusCode, err.code, err.docUrl, err.message);
  }
}
```

`code` and `docUrl` come from the API; see [Errors](https://strovio.xyz/docs/errors). Input checks in the SDK throw status 400 before any request, and timeouts throw status 408.

## Without the SDK

Until the package is published, the same calls work with `fetch` in Node.js 18+:

```js
import { readFile } from "node:fs/promises";

const api = "https://strovio.xyz/api/v1";
const headers = { Authorization: `Bearer ${process.env.STROVIO_API_KEY}` };

const put = await fetch(`${api}/files/reports/q1.pdf`, {
  method: "PUT",
  headers: { ...headers, "Content-Type": "application/pdf", "X-Access": "private" },
  body: await readFile("q1.pdf"),
});
if (!put.ok) throw new Error(JSON.stringify(await put.json()));

const file = await (await fetch(`${api}/files/reports/q1.pdf`, { headers })).json();
console.log(file.url);
```

Error bodies are `{ error, code, doc_url }`.

## Exports

`StrovioClient`, `StrovioError`, `DEFAULT_API_URL`, and the types `StrovioClientOptions`, `StrovioFile`, `StrovioFileDetail`, `StrovioListResult`, `StrovioUploadResult`, `StrovioDeleteResult`, `StrovioHeadResult`, `UploadOptions`, `ListOptions` and `AccessLevel`.

---

URL: https://strovio.xyz/docs/api
Markdown: https://strovio.xyz/docs/api.md

# REST API reference

- Base URL: `https://strovio.xyz/api/v1`
- Machine-readable: [OpenAPI 3.1 document](https://strovio.xyz/openapi.json)
- Auth: `Authorization: Bearer sk_live_...`, or `X-API-Key: sk_live_...` if you cannot set an `Authorization` header. Create keys at [strovio.xyz/developer](https://strovio.xyz/developer).
- Errors: JSON `{ "error": "...", "code": "...", "doc_url": "..." }`. See [Errors](https://strovio.xyz/docs/errors).
- Keys: `{path}` is exactly the path you uploaded to, such as `reports/q1.pdf`, or the full key from a response, such as `uploads/<account>/private/reports/q1.pdf`. Encode each segment, for example a space as `%20`. If the path exists as both a public and a private file, the path alone returns `409 ambiguous_key`.

## File object

| Field | Type | Notes |
|---|---|---|
| `key` | string | Full key: `uploads/<account>/<access>/<path>` |
| `name` | string | Your path on upload responses; the file name on list and get |
| `size` | integer | Bytes |
| `contentType` | string | Media type |
| `access` | `public` or `private` | |
| `url` | string or null | Public URL, signed URL (get, private files) or null |
| `expiresIn` | integer or null | Get only: 3600 for private files, null for public |
| `createdAt`, `updatedAt` | string | ISO 8601 |

## PUT /files/{path}

Upload or replace a file. Body: the raw bytes, up to 512 MB (536,870,912 bytes). Uploading to a path that exists with the same access replaces it; with the other access it creates a second file.

Headers: `Content-Type` (stored with the file), `X-Access: public` for a public file (default private).

`201` returns the file object.

## GET /files

List files, newest first. Query: `prefix` (key contains this text anywhere: `reports/` also matches `old/reports/x.pdf`), `limit` (whole number from 1, default 1000, values above 1000 are treated as 1000).

`200` returns `{ "objects": [file], "count": n }`.

## GET /files/{path}

Get a file's details and a download `url`. `200` returns the file object with `expiresIn`. `404 file_not_found` if no file matches, `409 ambiguous_key` if the path is both public and private.

## HEAD /files/{path}

`200` with `Content-Length`, `Content-Type`, `X-Access` and `Last-Modified` headers, `404` or `409`. No body.

## DELETE /files/{path}

Permanently delete a file and its share links. `200` returns `{ "ok": true, "key": "..." }`.

## POST /files/multipart/start

Body: `{ "key", "size", "contentType"?, "access"? }`. `200` returns `{ "uploadId", "s3Key", "bucket", "parts": [{ "partNumber", "url", "contentLength" }] }`. See [Upload large files](https://strovio.xyz/docs/large-uploads).

## POST /files/multipart/complete

Body: `{ "s3Key", "uploadId", "key", "parts": [{ "PartNumber", "ETag" }], "contentType"?, "access"? }`. `201` returns the file object.

## POST /files/presign-put

Body: `{ "key", "size", "contentType"?, "access"? }`. `200` returns `{ "putUrl", "s3Key", "bucket" }`. `PUT` the bytes to `putUrl` within one hour with the same `Content-Type`.

## POST /files/complete

Body: `{ "key", "contentType"?, "access"? }`, after a successful `PUT` to a `putUrl`. `201` returns the file object.

## GET /api/health

`https://strovio.xyz/api/health` needs no key and returns `{"ok":true,...}` when the service is up.

## Idempotency and retries

Writes are keyed by path and access: retrying a `PUT` or a complete call with the same key and access replaces the same file and never creates a duplicate. The API does not store `Idempotency-Key` values. Retry `5xx` errors with backoff; do not retry `4xx` errors without changing the request. A retried `DELETE` whose first attempt succeeded returns `404 file_not_found`.

## Not available with an API key

Share links, folders, stars, trash, search and billing are dashboard features and need a signed-in browser session.

---

URL: https://strovio.xyz/docs/errors
Markdown: https://strovio.xyz/docs/errors.md

# Errors

API errors return JSON with three fields:

```json
{
  "error": "File not found. List your files with GET /api/v1/files and use the key it returns.",
  "code": "file_not_found",
  "doc_url": "https://strovio.xyz/docs/errors#file_not_found"
}
```

`error` is a plain sentence that says what to do. `code` is stable; match on it, not on the sentence. `doc_url` links to the section below. `HEAD` requests return the status only, without a body. The SDK exposes these as `StrovioError.statusCode`, `code` and `docUrl`.

## invalid_api_key

Status 401. The request had no API key, a malformed one, or a key that was deleted.

Fix: send `Authorization: Bearer sk_live_...` with a key from [strovio.xyz/developer](https://strovio.xyz/developer). Check the environment variable is set in the process that sends the request. If the key was lost or deleted, create a new one. See [Create an account and an API key](https://strovio.xyz/docs/get-an-api-key).

## invalid_request

Status 400. A required field is missing or a value is out of range, for example a `limit` that is not a positive whole number, a missing `key` or `size`, or a multipart `s3Key` that does not match `key` and `access`.

Fix: read the `error` sentence, correct that field, and send the request again.

## file_not_found

Status 404. No file in your account matches the path or key.

Fix: list your files with `GET /api/v1/files?prefix=<part of the path>` and use the `key` it returns. Paths are case-sensitive and must match exactly; `a.txt` does not find `reports/a.txt`.

## ambiguous_key

Status 409. The same path exists as both a public and a private file, so the path alone does not say which one you mean. `HEAD` returns `409` without a body.

Fix: send the full key, `uploads/<account>/public/<path>` or `uploads/<account>/private/<path>`, from `GET /api/v1/files`.

## file_too_large

Status 413. The file is over 512 MB.

Fix: Strovio does not accept files over 512 MB. Split or compress the file. Under 512 MB, use a [multipart upload](https://strovio.xyz/docs/large-uploads) if a single request fails.

## storage_quota_exceeded

Status 413. This upload would take your account over its storage limit.

Fix: delete files you no longer need, or upgrade at [strovio.xyz/billing](https://strovio.xyz/billing).

## storage_limit_reached

Status 413, from `presign-put`. Your plan's storage is full or your trial or plan has ended. The body also has `usedBytes`, `limitBytes` and `upgrade: true`.

Fix: upgrade at [strovio.xyz/billing](https://strovio.xyz/billing) or delete files.

## upload_not_found

Status 400, from `POST /files/complete`. Storage has no object for this key yet.

Fix: finish the `PUT` to the `putUrl` first and check it returned `200`, then call complete with the same `key` and `access`.

## forbidden

Status 403, from `multipart/complete`. The `s3Key` belongs to another account.

Fix: use the `s3Key` returned by your own `multipart/start` call, with the same API key.

## internal_error

Status 500. Something failed on Strovio's side.

Fix: retry with exponential backoff, for example after 1, 2 and 4 seconds. If it keeps failing, check `https://strovio.xyz/api/health` and email support@strovio.xyz with the time and the endpoint.

## Errors outside the API

- SDK input checks (status 400) and timeouts (status 408) happen before or instead of a response; the message says which value to change.
- Share link downloads return plain text: see [Share a file with a link](https://strovio.xyz/docs/share-links).
- A signed URL that has expired returns an XML `AccessDenied` or `Request has expired` error from `s3.strovio.xyz`. Request a new URL with `GET /api/v1/files/{path}`.

---

URL: https://strovio.xyz/use-cases/file-storage-api-with-public-and-expiring-links
Markdown: https://strovio.xyz/use-cases/file-storage-api-with-public-and-expiring-links.md

# A simple file storage API with public links and expiring URLs

Strovio is a file storage API for developers who want to upload a file and get a link back, without setting up buckets, IAM policies or a CDN account. One `PUT` request uploads a file. A public file gets a permanent URL. A private file gets a signed URL that expires after one hour each time you ask for it.

## How it works

1. Create an API key at [strovio.xyz/developer](https://strovio.xyz/developer).
2. Upload: `PUT https://strovio.xyz/api/v1/files/<path>` with the bytes, a `Content-Type` and `X-Access: public` or `private`.
3. Link: public uploads return `url` straight away. For private files, `GET https://strovio.xyz/api/v1/files/<path>` returns a signed `url` valid for 3600 seconds.

The same operations are available in the [TypeScript SDK](https://strovio.xyz/docs/sdk), in the [MCP server](https://strovio.xyz/docs/mcp) for AI agents, and in a web dashboard with folders, search, trash and share links.

## Who Strovio suits

- Small apps, side projects and internal tools that need to store user uploads, reports, exports or build artefacts and hand out links.
- Developers who want one API key instead of an access key, a secret, a region, a bucket policy and a CORS policy.
- Teams who also want people to manage the same files in a browser.
- AI agents that need to save a file and return a link to a person.

## Who it does not suit

- Workloads that need a global CDN. Public files are served directly from `s3.strovio.xyz`, not from edge locations.
- Files over 512 MB, or more than 100 GB in one account (the largest plan).
- Anyone who needs the S3 API itself, bucket-level settings, lifecycle rules, object versioning, regions, signed URLs longer than one hour, or a published uptime SLA. Strovio offers none of these today.
- Browser apps that upload directly from the user's device with a public key. The API key is a secret and must stay on your server.

## Pricing

A 14-day free trial with 2 GB and no card, then Pro at $10 a month for 25 GB or Team at $28 a month for 100 GB and 5 members. There are no separate request or download charges.

## Frequently asked questions

### Does Strovio give public files a permanent URL?

Yes. A file uploaded with `X-Access: public` returns a `url` that works for anyone until the file is deleted.

### How long do private file links last?

Signed URLs for private files last one hour. Request a new one with `GET /api/v1/files/<path>` when it expires. For a link that does not expire, create a share link in the dashboard.

### Is Strovio S3-compatible?

No. Strovio has its own small REST API. It stores files on S3-compatible storage underneath, but you cannot point an S3 client at Strovio.

### Is there a free tier?

There is a 14-day free trial with 2 GB of storage and no card. After that a paid plan is needed.

## Get started

[Create an account](https://strovio.xyz/signup), then follow [Upload, list, download and delete files](https://strovio.xyz/docs/upload-and-download).

---

URL: https://strovio.xyz/use-cases/file-storage-mcp-server-for-ai-agents
Markdown: https://strovio.xyz/use-cases/file-storage-mcp-server-for-ai-agents.md

# File storage with an MCP server for AI agents

Strovio gives AI agents a place to put files and a link to hand back. Its MCP server, `strovio-mcp`, adds five tools to any local MCP client such as Claude Code, Claude Desktop, Cursor or Codex: `list_files`, `upload_file`, `get_file`, `file_exists` and `delete_file`.

## What an agent can do

- Save a generated report, image or export and give the person a link.
- Keep files private and hand out a download link that expires after one hour.
- Find earlier uploads by path and check whether a file exists before overwriting it.
- Clean up its own test files.

## Setup in one line

```bash
claude mcp add -s user strovio -e STROVIO_API_KEY="$STROVIO_API_KEY" -- npx -y strovio-mcp
```

Instructions for Claude Desktop, Cursor and Codex, on macOS, Windows and Linux, are in [Connect an AI agent with MCP](https://strovio.xyz/docs/mcp). Check the package is published first with `npm view strovio-mcp version`; until it is, agents use the [REST API](https://strovio.xyz/docs/api), which does everything the tools do.

Agents that can make HTTP requests but cannot run MCP servers can use the [REST API](https://strovio.xyz/docs/api), and every docs page is available as Markdown from [llms.txt](https://strovio.xyz/llms.txt).

## Who it suits

- People who use a local coding agent and want it to store files and share links without a cloud console.
- Developers building agent workflows that produce files for people.

## Who it does not suit

- Browser-only assistants such as ChatGPT on the web. Strovio has no hosted (remote) MCP server yet, so they cannot connect.
- Agents that must create share links that never expire. Those are made in the dashboard by a person today.
- Uploads over 50 MiB through the MCP server; use the REST multipart upload instead.

## Frequently asked questions

### Which AI tools can use the Strovio MCP server?

Any MCP client that can start a local stdio server with Node.js 18 or later, including Claude Code, Claude Desktop, Cursor and Codex.

### How does the MCP server authenticate?

With a Strovio API key in the `STROVIO_API_KEY` environment variable, set in the client's MCP configuration.

### Is there a remote MCP server with OAuth?

Not yet. The MCP server runs locally on your computer.

### What does it cost?

The MCP server is free to install. It uses your Strovio account: a 14-day free trial, then Pro at $10 a month or Team at $28 a month.

---

URL: https://strovio.xyz/use-cases/simple-s3-alternative-for-small-apps
Markdown: https://strovio.xyz/use-cases/simple-s3-alternative-for-small-apps.md

# A simpler alternative to Amazon S3 for small apps

Strovio is a simpler option than Amazon S3 when a small app only needs to upload files, list them, and hand out public or expiring links. You get one API key and a few endpoints instead of an AWS account, IAM credentials and bucket settings. Amazon S3 is the better choice when you need its scale, its API or its controls.

## What you skip with Strovio

- Creating an AWS account, a bucket and IAM credentials.
- Configuring which files are public: in Strovio it is one header per upload.
- Signing requests: Strovio uses a bearer API key.

## What you give up

- The S3 API and the tools built on it. Strovio is not S3-compatible.
- Scale: Strovio files are limited to 512 MB, and the largest plan holds 100 GB.
- Controls: no storage classes, versioning, lifecycle policies, replication or event notifications.
- Signed URLs longer than one hour. S3 allows up to 7 days with long-term credentials.
- A published uptime SLA.

## Pricing model

Strovio has flat monthly plans: $10 for 25 GB and $28 for 100 GB, after a 14-day free trial. Amazon S3 charges by usage, for storage, requests and data transfer; see the [Amazon S3 pricing page](https://aws.amazon.com/s3/pricing/).

See the full [Strovio vs Amazon S3 comparison](https://strovio.xyz/compare/strovio-vs-amazon-s3).

## Frequently asked questions

### Can I move from Strovio to S3 later?

Yes. List your files with `GET /api/v1/files`, download each with its URL, and upload to S3. There is no automatic export.

### Does Strovio run on S3?

Strovio stores files on its own S3-compatible object storage server, not on Amazon S3.

### Is Strovio cheaper than S3?

It depends on your usage. Strovio is a flat monthly price with no request or download charges; S3 is pay as you go. Compare your expected storage, requests and downloads against both pricing pages.

---

URL: https://strovio.xyz/compare/strovio-vs-amazon-s3
Markdown: https://strovio.xyz/compare/strovio-vs-amazon-s3.md

# Strovio vs Amazon S3

Amazon S3 is general-purpose object storage with a very large feature set. Strovio is a small file storage service with a simple API, a dashboard and an MCP server for AI agents. Choose S3 for scale, the S3 API and fine-grained control; choose Strovio when you want to upload files and hand out links with one API key.

Amazon S3 facts were checked on 7 November 2026 on the [Amazon S3 pricing page](https://aws.amazon.com/s3/pricing/), the [S3 features page](https://aws.amazon.com/s3/features/) and the [S3 presigned URL guide](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html).

| | Strovio | Amazon S3 |
|---|---|---|
| Pricing model | Flat monthly plans: $10 for 25 GB, $28 for 100 GB | Pay as you go for storage, requests and data transfer |
| Free offer | 14-day trial, 2 GB, no card | New AWS customers get up to $200 in AWS Free Tier credits; first 100 GB a month of data transfer out to the internet is free, aggregated across AWS services |
| Download charges | None | Charged per GB beyond the free allowance |
| API | Own REST API | S3 API |
| Auth | One bearer API key | AWS security credentials (IAM) |
| Expiring links | Signed URLs valid 1 hour | Presigned URLs up to 7 days with IAM user credentials (Signature Version 4) |
| Never-expiring share links | Yes, from the dashboard | Not compared here |
| Storage controls | None beyond public or private per file | Storage classes, S3 Versioning, S3 Lifecycle policies, replication and S3 Event Notifications |
| Web dashboard for non-developers | Yes, with folders, search, trash and share links | AWS console |
| MCP server for AI agents | Yes, `strovio-mcp` (local stdio; check `npm view strovio-mcp version` for availability) | Not compared here |

## Choose Amazon S3 if

- You need the S3 API, files over 512 MB, or more than 100 GB.
- You need storage classes, versioning, lifecycle policies, replication or event notifications.
- You already run on AWS.

## Choose Strovio if

- You want one API key and a few endpoints to upload files and get links.
- You want people to manage the same files in a browser.
- You want an AI agent to store files through MCP.
- A flat monthly price suits you better than usage billing.

## Frequently asked questions

### Is Strovio built on Amazon S3?

No. Strovio runs its own S3-compatible object storage server.

### Can I use the AWS SDK with Strovio?

No. Strovio's storage server speaks the S3 protocol internally, but it is not exposed to customers and Strovio API keys are not AWS credentials. Use Strovio's REST API, its TypeScript SDK or its MCP server.

---

URL: https://strovio.xyz/compare/strovio-vs-cloudflare-r2
Markdown: https://strovio.xyz/compare/strovio-vs-cloudflare-r2.md

# Strovio vs Cloudflare R2

Cloudflare R2 is object storage with an S3 API and no egress charges, priced by usage. Strovio is a small file storage service with its own simple API, a dashboard and an MCP server, priced by flat monthly plans. Choose R2 for the S3 API, larger scale and Cloudflare's platform; choose Strovio for the simplest path from upload to link.

Cloudflare R2 facts were checked on 7 November 2026 on the [R2 pricing page](https://developers.cloudflare.com/r2/pricing/) and the [R2 presigned URL guide](https://developers.cloudflare.com/r2/api/s3/presigned-urls/).

| | Strovio | Cloudflare R2 |
|---|---|---|
| Pricing model | Flat monthly plans: $10 for 25 GB, $28 for 100 GB | Usage: $0.015 per GB-month (Standard), $4.50 per million Class A operations, $0.36 per million Class B operations |
| Free offer | 14-day trial, 2 GB, no card | Monthly free tier: 10 GB-month of storage, 1 million Class A and 10 million Class B operations (Standard storage) |
| Egress | No download charges | Free |
| API | Own REST API | S3 API |
| Expiring links | Signed URLs valid 1 hour | Presigned URLs from 1 second to 7 days, for GET, HEAD, PUT and DELETE |
| Never-expiring share links | Yes, from the dashboard | Not compared here |
| Web dashboard for non-developers | Yes, with folders, search, trash and share links | Cloudflare dashboard |
| MCP server for AI agents | Yes, `strovio-mcp` (local stdio; check `npm view strovio-mcp version` for availability) | Not compared here |

## Choose Cloudflare R2 if

- You need the S3 API or already use Cloudflare.
- You store more than 100 GB, or files over 512 MB.
- Usage pricing with a monthly free tier fits your workload.

## Choose Strovio if

- You want one API key and a few endpoints, with no request signing.
- You want people to manage the same files in a browser, with share links.
- You want an AI agent to store files through MCP.

## Frequently asked questions

### Does Strovio charge for downloads?

No. Plans have a storage allowance and no request or download charges.

### Is Strovio S3-compatible like R2?

No. Strovio has its own REST API.

---

URL: https://strovio.xyz/compare/strovio-vs-uploadthing
Markdown: https://strovio.xyz/compare/strovio-vs-uploadthing.md

# Strovio vs UploadThing

UploadThing is a file upload service built for full-stack TypeScript apps, with adapters and upload components for many frameworks. Strovio is a file storage service with a plain REST API, a dashboard and an MCP server for AI agents. Choose UploadThing to add upload buttons to a TypeScript web framework; choose Strovio to store files from any language, script or agent and hand out links.

UploadThing facts were checked on 7 November 2026 on the [UploadThing pricing page](https://uploadthing.com/pricing) and the [UploadThing docs](https://docs.uploadthing.com/).

| | Strovio | UploadThing |
|---|---|---|
| Plans | 14-day trial (2 GB), Pro $10 a month (25 GB), Team $28 a month (100 GB) | Free (2 GB), $10 a month (100 GB), Usage Based $25 a month (250 GB, then $0.08 per GB) |
| Built for | Any language that can make HTTP requests, plus a TypeScript SDK | Full-stack TypeScript apps: Next.js, Astro, SolidStart, SvelteKit, Nuxt and others, with React, Vue, SolidJS and Svelte components |
| Upload components for web apps | No | Yes |
| Plain REST API for scripts and other languages | Yes | Not compared here |
| Private files | Yes, on every plan | Listed on the $10 and Usage Based plans |
| Web dashboard for managing files | Yes, with folders, search, trash and share links | Yes |
| MCP server for AI agents | Yes, `strovio-mcp` (local stdio; check `npm view strovio-mcp version` for availability) | Not compared here |

## Choose UploadThing if

- You are building a TypeScript web app and want ready-made upload components and framework adapters.
- You want a free plan rather than a trial.

## Choose Strovio if

- You upload from scripts, back ends in any language, CI jobs or AI agents.
- You want people to browse and share the same files in a dashboard.
- You want an MCP server for your coding agent.

## Frequently asked questions

### Does Strovio have upload components for React?

No. Strovio is used from your server, scripts or agents; its API key must not be exposed in a browser.

### Does Strovio have a free plan?

It has a 14-day free trial with 2 GB and no card, then paid plans.