Give Your AI Safe Access to Object Data

Need storage? maskura store removes the cloud setup. Already have a bucket? maskura protects what reaches the agent.

Choose Your PathView on GitHub

maskura store

Private preview

You’re building the product. You shouldn’t have to build a storage platform too.

Give your agent a place to put files.

maskura store handles the bucket, permissions, encryption, and cleanup. Your code uses MCP or S3 and gets back to the feature.

  • No bucket setup
  • MCP or S3
  • 1 GiB included

We’re validating uploads, storage limits, and reliable deletion before opening access.

Join Store preview

maskura

Available now

You already protected customer data in your bucket. Agent prompts, traces, and tool logs are a new boundary.

Keep sensitive fields out of the agent’s context.

maskura sits between the agent and your existing S3-compatible storage. It redacts or encrypts supported content on the way through, without creating another clean-data copy to manage.

  • Keep existing storage
  • Protect reads + writes
  • No duplicate clean bucket
Protect my bucket

Raw data is plaintext? No problem — read through maskura, scrubbed on the way to the AI.

Write path — your app PUTs, maskura cleans before storage.

Try it out

Prepare two records in your browser, then process them through maskura in plain, safe, and joinable modes.

5 trials remaining

maskura capabilities

Secure object access and privacy controls for your S3-compatible storage.

Agent-Safe ReadsCore

AI agents read your existing data through maskura — a GET with x-maskura-process: read runs the pipeline on the way out. Raw objects stay untouched; the model only ever sees redacted, encrypted output. No second cleaned copy to keep in sync.

MCP Agent AccessAgents

The public maskura-mcp stdio server gives Claude, Cursor, Codex, and other MCP clients put, get, list, and delete tools over the same gateway pipeline and billing path. Install it from the public maskura source or a GitHub release.

PII DetectionPrivacy

Detect and redact emails, SSNs, and credit cards on supported processed writes and opt-in processed reads. Modular detectors — enable only what you need.

Envelope EncryptionSecurity

RSA-OAEP + AES-256-GCM per field, with a fresh data key per write. maskura never sees your private key — decrypt only where you hold it.

Stable EncryptionAnalytics

Deterministic AES-SIV — same input, same output. Enables JOINs, deduplication, and analytics over encrypted data.

WASM Plugin PipelineExtensible

Run your own WASM components in a sandboxed pipeline — or write one with our SDK. Sandboxed, fuel-limited, and safe. That's the "WASM" you'll hear about; it's one capability among many.

S3 & SigV4 CompatibleDrop-in

Any S3 client works — AWS CLI, SDKs, aws s3 cp. SigV4-signed requests verified, bodies tamper-checked.

Bounded-Memory StreamingScale

Hosted single PUT and GET requests are currently capped at 64 MiB and stream with bounded memory where the pipeline is prefix-safe. Text records and complete JSON documents are capped at 8 MiB. A read that cannot be streamed safely may use a temporary encrypted local spool within a shared 256 MiB process quota; stale artifacts are cleanup-bounded.

Pay As You GoBilling

No subscriptions or base fees. Successful PUT and DELETE operations count as writes; successful GET, HEAD, and LIST operations count as reads. Only successful PUT/GET data adds processed bytes, and failed operations are not billed. See rates and byte calculation.

Supported formats

maskura transforms text records and schema-aware Avro OCF objects through format-specific privacy pipelines.

Available now

JSONL, JSON, CSV, TSV, plain text, and Avro OCF are selected by Content-Type and can be processed on write and read.

In development

Parquet will add schema-aware columnar processing. Other unsupported binary objects remain raw S3 passthrough.

See format behavior and the roadmap

Give your AI safe access to your data

Free tier every month. Pay as you go after that.

See Pricing

Examples

Use the same S3-compatible gateway from your CLI, application code, or local MCP server. Writes run the configured pipeline; processed reads opt in with x-maskura-process: read.

Billing follows the S3 operation, regardless of client: successful PUT and DELETE operations count as writes; successful GET, HEAD, and LIST operations count as reads. Only PUT and GET add processed bytes, calculated as max(source bytes, stored/emitted output bytes); metadata operations, LIST, HEAD, and DELETE have zero processed bytes. Failed operations are not billed.

maskura speaks the S3 API — point any S3 client at the gateway. PII is redacted before it lands in your bucket.

# maskura credentials retain the s4_ and s4s_ prefixes for compatibility
export AWS_ACCESS_KEY_ID=s4_your_access_key
export AWS_SECRET_ACCESS_KEY=s4s_your_secret_key
export AWS_ENDPOINT_URL=https://api.s4.231self.com

# Write an object — email + card are detected and redacted in transit
aws s3 cp customer.json s3://my-bucket/customer.json \
  --endpoint-url $AWS_ENDPOINT_URL

# Or with curl (header auth)
curl -X PUT https://api.s4.231self.com/my-bucket/contact.json \
  -H "x-maskura-access-key: s4_your_access_key" \
  -H "x-maskura-secret-key: s4s_your_secret_key" \
  -H "Content-Type: application/json" \
  --data-binary '{"email":"alice@example.com","card":"4111111111111111"}'

# Read it back — stored object is redacted
curl https://api.s4.231self.com/my-bucket/contact.json \
  -H "x-maskura-access-key: s4_your_access_key" \
  -H "x-maskura-secret-key: s4s_your_secret_key"

Use boto3 with a maskura API key as SigV4 credentials and point it at the gateway endpoint.

pip install boto3

import boto3

s3 = boto3.client(
    "s3",
    endpoint_url="https://api.s4.231self.com",
    aws_access_key_id="s4_your_access_key",
    aws_secret_access_key="s4s_your_secret_key",
    region_name="us-east-1",
)

# Write through the configured maskura pipeline.
s3.put_object(
    Bucket="my-bucket",
    Key="customer.json",
    ContentType="application/json",
    Body=b'{"email":"alice@example.com","card":"4111111111111111"}',
)

# Read the stored representation.
stored = s3.get_object(Bucket="my-bucket", Key="customer.json")
print(stored["Body"].read().decode())

Install the public stdio server, create an MCP token in the dashboard, and register the command with your MCP client. Full details are in docs/mcp.md.

cargo install --git https://github.com/231self/maskura maskura-mcp

// claude_desktop_config.json, .cursor/mcp.json, or equivalent
{
  "mcpServers": {
    "maskura": {
      "command": "maskura-mcp",
      "env": {
        "MASKURA_GATEWAY_URL": "https://api.s4.231self.com",
        "MASKURA_MCP_TOKEN": "s4m_your_token"
      }
    }
  }
}

# Available tools:
# maskura_put_object, maskura_get_object, maskura_list_objects, maskura_delete_object
# Legacy s4_* tools and s4-mcp remain aliases during the transition.