About
How this site works
poegems.net ranks Path of Exile skill gems by two specific economic plays: buying a level 1 gem and selling it after leveling, and corrupting a max-level gem with a Vaal Orb or Doryani's Institute. This page explains where the prices come from, how the math is constructed, and where the model is deliberately conservative.
Where the prices come from
Every price on the site is sourced from the public PoE economy data aggregator. We pull a complete snapshot of the SkillGem index once an hour via a scheduled GitHub Actions job, which writes the result to a static JSON file served alongside the pages. There is no per-request scraping, no third-party tracking pixel doing work on your behalf when you visit; the page just fetches a static blob and renders it client-side.
The hourly cadence matches what the upstream aggregator itself refreshes at, so faster refreshing would just re-fetch stale data. The "Updated X ago" indicator under the filter row tells you exactly how stale the snapshot you're looking at is.
How leveling profit is computed
For each gem at each tracked quality (0% and 20%), we look up the cheapest fair-market listing at level 1 and the cheapest at the gem's max uncorrupted level. Max level depends on the gem's tier:
- Regular and transfigured skill gems: max level 20
- Awakened support gems: max level 5
- Exceptional supports (Empower, Enhance, Enlighten): max level 3
Profit is the simple difference:
profit = price(max level) − price(L1).
ROI is expressed as a percentage of the L1 input, capped at thresholds
appropriate to the magnitude (over 1000% renders as a multiplier like
12×
rather than 1200%).
Both numbers are deliberately blind to the time required to actually level
the gem, because that time cost is so individual it would distort rankings
for everyone but the median player.
Quality 0 and Quality 20 versions of each gem are tracked as separate rows, because they behave like distinct items on the market. Other qualities (1–19, plus corrupted-only values like 23) aren't included because they're not generally traded as endpoints.
How corruption EV is computed
Each Vaal Orb on a skill gem produces one of four outcomes, each weighted at 25%:
- No change — the gem just becomes corrupted, same level and quality
- Level changed — gem level shifts by ±1 (split 12.5% / 12.5%)
- Quality changed — quality is rerolled uniformly to a value in 0–23
- Transformation — the gem becomes its Vaal variant (Vaal Spark, Vaal Reave, etc.) if one exists; otherwise the slot collapses to no-change
Expected value is the probability-weighted average of each outcome's post-corruption market price. Subtracting the input gem cost and the Vaal Orb cost gives expected profit per attempt.
Double corruption (Doryani's Institute Tier 3 inside the Temple of Atzoatl) is modeled as two independent corruption rolls applied sequentially. That produces 25 terminal-state paths in the probability tree, each priced from market data and weighted by joint probability. The cost basis subtracts a Tier 3 Doryani's Institute Temple at its current trade price, not two individual Vaal Orbs — the orbs are consumed by the Temple mechanic, not purchased separately.
The data-quality cap (and why your EVs look conservative)
A subtle bias shows up in the raw economy data: for many gems, the listed "corrupted at the same level and quality as uncorrupted" price is wildly higher than the uncorrupted price — sometimes 100×. Same effective stats, enormous price gap. If that price were taken at face value, mass-Vaal-orbing cheap gems would look like a free-money exploit, but it isn't one. The most plausible explanation is listing-selection bias: a corrupted gem that rolled identical stats is essentially the same as the uncorrupted version, so the only reason to list it is at an aspirational mark-up, hoping for a buyer who isn't comparing.
To avoid those aspirational listings dominating expected value, we cap every non-upgrade outcome at the uncorrupted input price. Outcomes that are genuinely distinct upgrades — a +1 level corruption, a Vaal-version transformation, a quality reroll that lands above the input quality — stay uncapped because those listings reflect real, defensibly different items.
The practical result: corruption EV numbers on this site lean intentionally conservative. If anything, real outcomes for a careful trader should slightly exceed our estimates rather than fall short.
The "high confidence" filter
Both the leveling and corruption pages have a "High confidence only" toggle that's on by default. It hides any row where fewer than 10 unique sellers had listings of the input gem at snapshot time. Thin markets are noisy: a single mispriced listing can swing the visible price by an order of magnitude. The 10-seller floor isn't a guarantee the price you'll pay matches what we show, but it's a reasonable proxy for "this is a real market with real activity."
Attribute requirements
The Strength / Dexterity / Intelligence requirements shown for each gem are the requirements at max level, which is what you'd need to socket the gem after leveling it. They're derived once from the community-maintained RePoE data set and committed to the repository, so there's no runtime dependency on a third-party source for them. The "Char Attrs" filter uses these to hide gems your character can't socket.
What this site is not
The prices shown are asking prices, not confirmed sale prices. There is no public feed of completed PoE trades; everything in any economy aggregator is derived from active listings. When the market is thick (popular gems with hundreds of online listings) the asking-price proxy is generally honest. When it's thin (rare transfigured variants, low-population leagues, late-league dead markets) the asking price drifts away from real clearing prices and the listings here will reflect that drift. Use the high-confidence toggle and the listing-count signals to discount accordingly.
Open source
The site, the pipeline, and the pricing math live in a public repository
under a source-available license. The full algorithm is in
scripts/fetch_prices.py;
if you find a case where the EV math looks wrong, you can read the exact
code that produced the number.