Prerequisites

You need a Solana keypair file. Generate one with:

solana-keygen new --outfile keypair.json --no-bip39-passphrase

Then connect this wallet to the portal once to create your account, or use the keypair directly with the SIWS flow below.

curl

# 1. Get challenge
CHALLENGE=$(curl -s -X POST "$API_BASE/auth/siws/challenge" \
  -H "Content-Type: application/json" \
  -d '{"wallet_public_key":"YOUR_WALLET_PUBKEY"}')

# 2. Sign the "message" field with your private key (use solana CLI or SDK)
# 3. Verify
curl -X POST "$API_BASE/auth/siws/verify" \
  -H "Content-Type: application/json" \
  -d '{
    "wallet_public_key":"YOUR_WALLET_PUBKEY",
    "nonce":"FROM_CHALLENGE",
    "message":"FROM_CHALLENGE",
    "signature_b64":"BASE64_ENCODED_SIGNATURE"
  }'
# Returns: { "access_token": "...", "refresh_token": "...", "csrf_token": "..." }

Python (solders + requests)

import json, base64, requests
from solders.keypair import Keypair

API = "https://us-west-01-firestarter.pipenetwork.com"

# Load Solana CLI keypair (64-byte JSON array)
kp = Keypair.from_bytes(bytes(json.load(open("keypair.json"))))
wallet = str(kp.pubkey())

# 1. Get challenge
r = requests.post(f"{API}/auth/siws/challenge",
    json={"wallet_public_key": wallet})
challenge = r.json()

# 2. Sign the challenge message
sig = kp.sign_message(challenge["message"].encode())
sig_b64 = base64.b64encode(bytes(sig)).decode()

# 3. Verify and get tokens
r = requests.post(f"{API}/auth/siws/verify", json={
    "wallet_public_key": wallet,
    "nonce": challenge["nonce"],
    "message": challenge["message"],
    "signature_b64": sig_b64,
})
tokens = r.json()
access_token = tokens["access_token"]
csrf_token = tokens["csrf_token"]

# Use it — get your API key
headers = {"Authorization": f"Bearer {access_token}"}
me = requests.get(f"{API}/user/me", headers=headers).json()
print("API key:", me["user_app_key"])

Install: pip install solders requests

Node.js (@solana/web3.js + tweetnacl)

import { Keypair } from "@solana/web3.js";
import nacl from "tweetnacl";
import { readFileSync } from "fs";

const API = "https://us-west-01-firestarter.pipenetwork.com";

// Load Solana CLI keypair
const secret = new Uint8Array(JSON.parse(readFileSync("keypair.json", "utf8")));
const kp = Keypair.fromSecretKey(secret);
const wallet = kp.publicKey.toBase58();

// 1. Get challenge
const { nonce, message } = await fetch(`${API}/auth/siws/challenge`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ wallet_public_key: wallet }),
}).then(r => r.json());

// 2. Sign
const sig = nacl.sign.detached(new TextEncoder().encode(message), kp.secretKey);
const signature_b64 = Buffer.from(sig).toString("base64");

// 3. Verify
const tokens = await fetch(`${API}/auth/siws/verify`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ wallet_public_key: wallet, nonce, message, signature_b64 }),
}).then(r => r.json());

// Use it
const me = await fetch(`${API}/user/me`, {
  headers: { Authorization: `Bearer ${tokens.access_token}` },
}).then(r => r.json());
console.log("API key:", me.user_app_key);

Install: npm install @solana/web3.js tweetnacl

curl + python decode

export PIPE_API_KEY=YOUR_USER_APP_KEY

# 1) Request x402 payment requirements
# Preferred for agents/headless clients: use user_app_key as ApiKey
curl -i -X POST "$API_BASE/api/credits/x402" \
  -H "Authorization: ApiKey $PIPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount_usdc_raw": 10000000}'

# 2) Decode the Payment-Required header (base64 JSON)
python - <<'PY'
import base64, json
raw = "PASTE_BASE64_HEADER"
print(json.dumps(json.loads(base64.b64decode(raw)), indent=2))
PY

# 3) Send USDC with the reference, then retry:
curl -i -X POST "$API_BASE/api/credits/x402" \
  -H "Authorization: ApiKey $PIPE_API_KEY" \
  -H "Payment-Signature: BASE64_JSON_INTENT_AND_TXSIG" \
  -H "Content-Type: application/json"

# 4) If confirm returns 202 Accepted, poll the intent:
curl -s "$API_BASE/api/credits/intent/INTENT_ID" \
  -H "Authorization: ApiKey $PIPE_API_KEY"

1. Get your credentials

Go to Storage → Keys, click "Create key", and download the .env file. Your agent needs these environment variables:

# .env — source this or add to your agent's environment
AWS_ACCESS_KEY_ID=<from portal: Storage → Keys → Create key>
AWS_SECRET_ACCESS_KEY=<shown once at creation — download the .env>
AWS_DEFAULT_REGION=auto
AWS_ENDPOINT_URL=<s3-endpoint>
PIPE_S3_BUCKET=<your-bucket>

2. Python (boto3)

import boto3

s3 = boto3.client(
    "s3",
    endpoint_url="<s3-endpoint>",
    region_name="auto",
    aws_access_key_id="YOUR_ACCESS_KEY_ID",      # from S3 key
    aws_secret_access_key="YOUR_SECRET_ACCESS_KEY",
)

# Upload
s3.upload_file("./test.txt", "<your-bucket>", "test.txt")

# Download
s3.download_file("<your-bucket>", "test.txt", "./test.txt")

# List objects
for obj in s3.list_objects_v2(Bucket="<your-bucket>").get("Contents", []):
    print(obj["Key"], obj["Size"])

3. Node.js (AWS SDK v3)

import { S3Client, PutObjectCommand, GetObjectCommand } from "@aws-sdk/client-s3";
import { readFileSync, writeFileSync } from "fs";

const s3 = new S3Client({
  endpoint: "<s3-endpoint>",
  region: "auto",
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
  },
  forcePathStyle: true,
});

// Upload
await s3.send(new PutObjectCommand({
  Bucket: "<your-bucket>",
  Key: "test.txt",
  Body: readFileSync("./test.txt"),
}));

// Download
const resp = await s3.send(new GetObjectCommand({
  Bucket: "<your-bucket>",
  Key: "test.txt",
}));
writeFileSync("./test.txt", await resp.Body.transformToByteArray());

4. AWS CLI

Source the .env file and use the standard AWS CLI:

source .env
aws s3 ls s3://<your-bucket> --endpoint-url <s3-endpoint>
aws s3 cp ./file.txt s3://<your-bucket>/file.txt --endpoint-url <s3-endpoint>

What's different from AWS S3?

AWS CLI migration

# Point your existing AWS CLI at Pipe Storage — just add --endpoint-url
aws s3 ls s3://<your-bucket> --endpoint-url <s3-endpoint>

# Migrate from AWS S3 to Pipe (one-liner)
aws s3 sync s3://my-aws-bucket s3://<your-bucket> \
  --source-region us-east-1 \
  --endpoint-url <s3-endpoint>

# Or copy a single file
aws s3 cp s3://my-aws-bucket/data.csv s3://<your-bucket>/data.csv \
  --endpoint-url <s3-endpoint>

rclone (S3-to-S3 sync)

# ~/.config/rclone/rclone.conf
[pipe]
type = s3
provider = Other
endpoint = <s3-endpoint>
access_key_id = YOUR_ACCESS_KEY_ID
secret_access_key = YOUR_SECRET_ACCESS_KEY
region = auto
acl = private

# Usage:
# rclone ls pipe:<your-bucket>
# rclone copy ./local-dir pipe:<your-bucket>/remote-dir
# rclone sync pipe:<your-bucket> ./backup

# Migrate from AWS S3 to Pipe in one command:
# rclone sync aws-remote:my-aws-bucket pipe:<your-bucket> --progress

Install: rclone.org/install

MinIO client (mc)

# Configure MinIO client
mc alias set pipe <s3-endpoint> YOUR_ACCESS_KEY_ID YOUR_SECRET_ACCESS_KEY

# Usage:
mc ls pipe/<your-bucket>
mc cp ./file.txt pipe/<your-bucket>/file.txt
mc mirror ./local-dir pipe/<your-bucket>/remote-dir

# Migrate from AWS S3:
mc alias set aws https://s3.amazonaws.com AWS_KEY AWS_SECRET
mc mirror aws/my-aws-bucket pipe/<your-bucket> --overwrite

Install: min.io/docs

Supported operations

SDK compatibility