Warframe.market is great for looking up one item at a time. This project flips that around: it continuously reads the public Warframe.market API, stores a daily price history, and turns it into screeners and tools that answer questions the official site can't at a glance —

Which prime sets are cheaper bought as parts? Which relics are worth cracking right now? What's my riven actually worth? What's a good flip this minute?

It's an independent, open-source fan project. Everything it shows is derived from public market data. There is no account system, no ads, and no tracking — the code is right here for you to read, run, or self-host. See Transparency & Trust for exactly how it sources data and handles privacy.

Live app → warframe-app.digitalshopuy.com

Live Signals — real-time buy / sell / flip verdicts	Set vs. Parts — cheaper assembled, or part-by-part?
Relic Value — crack it, or sell it?	Ducat Efficiency — most ducats per platinum for Baro
Flip Finder — realistic margins that actually clear	Vaulted — vaulted primes ranked by what they're worth

Runs anywhere — it's an installable PWA, so it works like a native app on your phone.

• What this is
• The tools
• A look inside
• Transparency & Trust
• Features
• Tech stack
• Architecture
• Quick start
• Full installation
• Configuration
• Data synchronization
• API reference
• Deployment
• Troubleshooting
• Contributing
• Support the project
• License & attribution

Because this tool is built for the community, here's the full, honest picture of how it works. Nothing below is hidden in the code.

• 100% from the public Warframe.market API and the community drop tables. No private endpoints, no logged-in scraping of other players, no in-game data extraction.
• Prices are synced on a schedule and cached, then served from our own database. The app builds a daily price-history series over time so it can show trends and discounts — a fresh deploy starts with an empty history and fills in as syncs run.
• Every number is an estimate from public order books. Markets move constantly — always confirm the live listing on Warframe.market before you trade.

• No account. No login. No email required. You never hand us any credentials.
• No ad networks, no third-party analytics selling your data.
• Your portfolio, alerts, and settings live in your own browser (localStorage) — they're never uploaded to a server, and they don't sync across devices for exactly that reason.
• Price alerts fire as local browser notifications while a tab is open. There's no push server watching your account.

The backend includes optional proxy rotation and request throttling (anti-detection.ts, ANTI_DETECTION_README.md). To be transparent about what that is and isn't:

• Its only purpose is to keep our own scheduled syncs from being rate-limited (HTTP 403) by the upstream CDN while reading public endpoints. It reads the same data any visitor to Warframe.market can see.
• It is not used to attack, spam, log into, or overload Warframe.market, and it does not touch the game client. It runs on a conservative interval with caching so we hit the upstream API as little as possible.
• Proxies are entirely optional — set PROXY_LESS=true and the app runs direct. No proxy lists or keys ship in this repo.

• This is a community fan project. It is not affiliated with, endorsed by, or operated by Digital Extremes (Warframe) or Warframe.market. All game content and trademarks belong to Digital Extremes.

• Fully open source (ISC). Read every line, self-host it, fork it, or open an issue. No secrets are required to run it — this repo ships only example templates and placeholders (see .env.example).

• Whole-market screener — every tradeable item in one sortable, filterable table (spread, discount, 48h volume, ducats).
• Real-time Live Signals — Socket.IO order feed with buy / sell / flip verdicts and thin-market safety flags.
• Relic, ducat & riven analytics — expected relic payouts, ducat efficiency for Baro, and riven value/Endo estimates.
• Daily price history & trend indicators — one price point per item per day, charted on the item detail view.
• Vault tracking — surface vaulted primes whose prices are spiking.
• Copy WTS/WTB — generates the standard trade-chat shorthand to paste into the game manually.
• In-browser portfolio & alerts — track holdings and set sell-price thresholds, stored locally.
• Full internationalization — multi-language UI (EN/ES and more).
• Installable PWA — add to home screen; works offline-friendly and mobile-first.
• Layered caching (Redis + edge) so cold paths never stall the API.

warframe/
├── app/                # Nuxt 4 + Vuetify 3 frontend (PWA)
│   ├── app/            # pages, components, composables
│   ├── i18n/           # translations
│   └── public/img/     # logo + screenshots
├── Express/            # Express server wrapper (routing, caching, rate limits)
├── services/           # data/analytics services
├── constants/          # shared constants
├── proxies/            # (optional, git-ignored) proxy lists
├── server.ts           # API entry point — registers all routes
├── live.ts             # real-time Socket.IO feed process
├── warframe.ts         # Warframe.market API client
├── anti-detection.ts   # optional proxy rotation / throttling
├── database.ts         # MongoDB connection + models
└── sync_*.ts           # scheduled data-sync scripts

Data flow: sync_*.ts reads the public Warframe.market API → normalizes and stores it in MongoDB (building a daily price history) → server.ts serves cached JSON through Redis + Cloudflare → the Nuxt app renders the tools.

Prefer not to run anything? Just use the live app. To run it yourself:

# 1. Clone
git clone https://github.com/eduair94/warframe
cd warframe

# 2. Install backend + frontend deps
npm run setup            # = npm install && cd app && npm install

# 3. Configure (only MONGODB_URI is strictly required)
cp .env.example .env     # edit MONGODB_URI; set PROXY_LESS=true to skip proxies

# 4. Seed the database (items first, then prices)
npm run sync_items
npm run sync_prices

# 5. Run — API + frontend in two terminals
npm run dev              # API  → http://localhost:3529
cd app && npm run dev    # web  → http://localhost:3312

Minimum to boot: Node ≥ 20, a reachable MongoDB, and PROXY_LESS=true. Everything else (Redis, proxies, reCAPTCHA, the live feed) is optional and degrades gracefully.

git clone https://github.com/eduair94/warframe
cd warframe
npm install          # backend
cd app && npm install && cd ..   # frontend

cp .env.example .env

At minimum, set your MongoDB connection and (if you don't have proxies) disable them:

MONGODB_URI=mongodb://localhost:27017/warframe
PROXY_LESS=true
API_PORT=3529

🔒 Your .env holds your real config and must never be committed. It's already in .gitignore. This repo intentionally contains no keys, proxies, or credentials — only .env.example.

The Nuxt app in app/ reads its own env for the API URL:

# app/.env
API_URL=http://localhost:3529
BASE_URL=http://localhost:3312

Local:

# Windows:  net start MongoDB
# macOS:    brew services start mongodb-community
# Linux:    sudo systemctl start mongod

Cloud: create a free Atlas cluster and paste its connection string into MONGODB_URI.

npm run sync_items && npm run sync_prices   # seed
npm run dev                                 # API
cd app && npm run dev                       # frontend

Core environment variables (see .env.example for the complete, commented list including Redis cache, cache warmer, and the live-feed process):

The sync_* scripts pull public data into MongoDB. Run sync_items first (everything else references it):

npm run sync_items      # all Warframe items (run first)
npm run sync_prices     # current market prices → builds daily history
npm run sync_rivens     # riven mod auctions
npm run sync_auctions   # auction data
npm run sync_drops      # relic drop tables

In production, PM2 (ecosystem.config.js) schedules these — items daily, prices/auctions on a rolling basis. Price history and trend indicators only become meaningful after sync_prices has run for several days, since the series is built one day at a time from public data.

The backend exposes a read-only JSON API (base path served from the API host). Responses are cached via Redis + edge.

build_relics / build_drops trigger live DB writes and are rate-limited + guarded by ADMIN_SYNC_TOKEN when set.

Builds the backend, frontend, and a MongoDB container together. .env must exist in the repo root first — Compose reads it for port substitution and to pass config into the API container:

cp .env.example .env      # edit with real settings
npm run docker:run        # docker-compose up -d
npm run docker:stop       # docker-compose down

In Compose, the API connects to the mongodb service directly (MONGODB_URI is overridden to mongodb://mongodb:27017/warframe).

npm run build && (cd app && npm run build)
pm2 start ecosystem.config.js
pm2 status && pm2 logs

npx kill-port 3529        # or change API_PORT / FRONTEND_PORT in .env

export NODE_OPTIONS="--max-old-space-size=4096"

Contributions are genuinely welcome — bug reports, translations, new tools, or fixes. See CONTRIBUTING.md for the full guide.

git checkout -b feature/my-improvement
# make changes; keep TypeScript + ESLint/Prettier happy
npm run lint && npm test
git commit -am "feat: describe your change"
git push origin feature/my-improvement   # then open a PR

Please also review SECURITY.md before submitting — and never commit real credentials, proxy lists, or .env files.

This is a free, no-ads, community project maintained on personal time. If it saves you platinum, a coffee is hugely appreciated (entirely optional — the tool stays 100% free either way):

The best free way to help: ⭐ star the repo, report bugs, and share it with your clan.

• License: ISC — free to use, modify, and self-host.
• Data: public Warframe.market API & community drop tables.
• Built with: Nuxt · Vuetify · Express · MongoDB · Socket.IO.

Disclaimer: Warframe Market Analytics is an independent, community-made fan project. It is not affiliated with, endorsed by, or operated by Digital Extremes or Warframe.market. Warframe and all related content are trademarks of Digital Extremes Ltd. All market figures are estimates from public data — always verify live listings before trading.