1. Getting started
    1. First run
    2. Character management
    3. Data synchronization
  2. Main tabs
    1. Character
    2. Statistics
    3. Assets
    4. Orders
    5. Journal
    6. Transactions
    7. Item history
    8. Market browser
    9. Item costs
    10. Market analysis
  3. Margin Tool
  4. HTTP Web Service
  5. Automatic update and email notifications
  6. Scripts
    1. Order object
    2. ExternalOrder object
    3. Global functions
  7. Other
    1. Text filters
    2. Source code compilation (Windows)
    3. Source code compilation (Linux)
    4. Source code compilation (OS X)
    5. Source code compilation (all)
    6. Docker
    7. Restoring database backup


Getting started

First run

After launching Evernus for the first time, a new database will be created and you will be asked for initial language selection. If your system language is supported, it should be selected by default. After choosing the language, the main window will show along with the Character Manager dialog. This is where you can manage characters, byt authorizing Evernus with EVE.

Character management

Each valid character will show in the Characters tab in the Character Manager. A character can be safely disabled, if you do not wish to track its market progress. Disabling a character does not delete any associated data, so you can enable it later and all historic data will still be available.

After authorizing your characters, you can begin synchronizing data.

Data synchronization

Most of the data Evernus uses is fetched from EVE Swagger Interface (ESI). Almost every tab has a “API import” button which uses this mechanism. Each call to ESI is cached locally and you will not get any new data until the cache timer expires – the time remaining is visible next to the buttons. There is also a “Import all” button used to import all the data at once.

Note: first data import can take some time and may show fulfilled orders up to 7 days old. Don’t worry – everything will get back to normal after next synchronization. Also, due to limitation with ESI, initial import of price data can take a long time when importing from citadels. ESI is unable to provide any info which citadels are available for given character, so Evernus needs to ask for each of those separately. This, combined with ESI rate limiting, can increase the import time even by a factor of 10. Next imports should be much faster, but Evenus needs to refresh citadel access data from time to time, as in the first import.

After the initial import, you can start using all the features Evernus has to offer.

Main tabs


The Character tab displays your character’s info sheet. Additionally to the portrait (which you can right-click to update) and basic info, there are:

  • Data age warnings (hidden if data is up-to-date).
  • Standing editors – standings for the station owner, where the trade takes place, should be entered manually here.
  • Skill editors – skills are imported by default (can be toggled in preferences) and can be adjusted to project expected earnings.


Your recorded progress as a trader is presented in this tab. Your total worth is expressed in the first plot, which shows your wallet balance, sell and buy order value, asset value and total value. Various graphs update their data during different time points (eg. order value is updated on order import) and the gaps between data points are filled with expected linear interpolation.

Second and third plots represent aggregated daily wallet journal and transaction income and outcome. All data can be combined for all characters to quickly see total profit/loss.

Reports tab shows quick reports on your overall progress with various item types and stations.

Advanced statistics enable you to create custom reports over historic orders. You can configure grouping, sorting and limiting of raw data with simple aggregation, and analyze it in tabular form. You can also make your own scripts to process the data, using QtScript based on ECMAScript (or JavaScript, if you wish).

Script processing can be run in two modes:

  • For each – each order (active and historic) is passed one by one to the script as parameter named order.
  • Aggregate – all orders (active and historic) are passed together to the script as an array of orders, named orders.

Each order is an object of type Order. You also can use the global object functions.

Evernus expects your script to end in a return statement, returning an array of values. Those will be added as a row of resulting data.


// uses "for each" mode to show all order data in the table
var result = [];

order.typeId = EveDataProvider.getTypeName(order.typeId);
order.stationId = EveDataProvider.getLocationName(order.stationId);

for (var prop in order)

return result;


Script For Each Sample

// uses "aggregate" mode to compute the count of all orders and thesum of all their prices
var sum = 0;
for (var i = 0; i < orders.length; ++i)
    sum += orders[i].price;

return [ orders.length, sum ];


Script Aggregate Sample


All assets in your possession are displayed on this tab along with their local sell value. To calculate their worth, each item needs local price data which can be imported form the web (using CREST) or from locally saved market logs/cache. If a price is unavailable or has not been updated recently, it will be shown with a yellow background. You can customize which station prices to use instead of the asset location.

Price update creates an asset value snapshot for statistics.


The Orders tab is divided into four more subtabs: Sell, Buy, Sell & Buy and History, which represent your market orders with different types (buy, sell) and in different stages (active, closed). The first two subtabs also show transactions associated with given order.

Each order has a variety of associated data:

  • Name of the item.
  • Item market group.
  • Order status (can be filtered by).
  • Custom cost (if any; sell only).
  • Price data.
  • Price data status (can be filtered by).
  • Price difference to the best market order.
  • Price difference to the best market order in %.
  • Volume remaining/volume entered.
  • Total remaining ISK value of the order.
  • Volume change since last update.
  • Margin calculated from item cost and profit (takes skills into account)
  • Profit from the remaining volume, calculated with respect to custom cost (sell only).
  • Total profit, calculated with respect to custom cost (sell only).
  • Profit per item, calculated with respect to custom cost (sell only).
  • Best margin (buy only) – margin if the order was currently the best one
  • Range (buy only)
  • Minimum quantity (buy only).
  • ETA
  • Time left.
  • Order age.
  • When the order was first seen by Evernus – order issued date is updated every on price change, while Evernus also tracks when the order first appeared, so you can avoid handling overdue orders.
  • Station where the order was placed.

Every order tracks its current price with respect to the most recently seen price of given item, with range taken into account. Yellow price background signalizes when the market price data is too old, while red background indicates that your order is not the top one at the moment. You can refresh market prices from the web (CREST) or from saved market logs/cache. Clicking on the price or the icon will bring up a helper window which contains more price information and allows you to copy a new price, which will take your order to the top.

You can use scripts to filter orders. Your script should be an expression, which can be evaluated to a boolean, eg:

order.price < 100000 && order.volumeRemaining > 5


The Journal tab shows wallet journal from selected timeframe. Every entry can be ignored, so it won’t be taken into account during statistics calculation.


The Transactions tab shows wallet transactions from selected timeframe. Every entry can be ignored, so it won’t be taken into account during statistics calculation.

Item history

The item history tab show you all the volume traded an profit made historically for a given item. You can also check the total progress you made over time.

Market browser

The browser allows you to see what price data Evernus has imported. You can quickly filter specific orders and locations and analyze various price statistics, like deviation.

Item costs

Custom costs can be entered in the Item costs tab. Such costs are taken into account during profit calculation in the Orders tab and during margin calculation in the Margin Tool. This behavior can be customized in Preferences. Costs can be added automatically when a buy order gets fulfilled.

Market analysis

Market analysis tabs allow you to inspect and analyze Eve markets in a very detailed way. Depending on your goal, you should use one (or more) specialized sub-tabs. For analysis to take place, you need to import order data from Eve, using region/station filters to specify where you want to trade. You can also change price types to match what you’re going to do (e.g. buying from sell orders and selling to buy orders), since those affect resulting calculations. After importing the data, go to the desired tab(s), setup up any further required parameters and hit “Apply” to begin calculations.

More help is available in tooltips on various elements.


Region analysis tab allows you to efficiently discover types suitable for station/region trading. You can quickly see the margins for given types within a single region/solar system.


Inter-region tab does in-depth analysis of possible cross-region trades. If you like to profit on regional price differences – this is the place to go.


Importing tab shows what item types are running low in the destination station, and what is the possible profit of stocking them up from the source station. If you like market seeding or you’re supplying your corp/alliance with goods – you can quickly identify holes in the market.

Ore reprocessing arbitrage

This tab shows you what profit can be made from buying ore/ice from the source, reprocessing it and selling in the destination. This is a fast and relatively safe way to make profit, but it requires you to be quick, since arbitrage opportunities usually don’t last long.

Note: you need to import both the source materials (ore/ice) and resulting minerals for arbitrage calculations to work.

Scrapmetal reprocessing arbitrage

Similar to ore arbitrage, scrapmetal arbitrage can help you quickly identify which item types can be bought, scrapped and sold for profit. As before, you need to import both source and resulting materials.

Margin Tool

The Margin Tool is a multipurpose tool aimed at quick market reconnaissance and price updating. Every time you export market logs from the game with the tool open, you will get detailed information about the profitability of trading given item. The tool also supports automatic copying of buy and sell price to the clipboard (modified to ensure being at the top). Desired profit margins and prices increments/decrements can be adjusted in the Preferences. Using it also updates item price database.

To quickly adjust your prices, export market logs with the tool open and paste new prices for your orders.

If you wish, you can specify custom station as a source for buy orders. This way you can check profit margins between different regions with just 2 clicks!

HTTP Web Service

Evernus supports HTTP web interface, which you can access from any web browser. Simply enable it in the Preferences, set the user and password needed to access the service and open the page in your browser. The user and password can be arbitrary – they only protect the service from unauthorized access.

Automatic update and email notifications

You can switch on automatic update in the Preferences. Specify the number of minutes between updates and optional email notifications about fulfilled orders. Note: you’ll need to enter SMTP server details, to make the notifications work.


Evernus uses QtScript based on ECMAScript (on which also JavaScript is based). Scripts can be used in advanced statistics calculation and order filtering. See ECMAScript/JavaScript documentation on how to write your own scripts.

Built-in object types:

Order object

The object contains these properties:

  • id – order id (due to QtScript limitation, stored as a string)
  • characterId – character id of the issuer (due to QtScript limitation, stored as a string)
  • stationId – id of the station where the order originated
  • volumeEntered – volume entered
  • volumeRemaining – volume remaining
  • minVolume – minimum volume
  • delta – change since last update
  • state – order state (0 = open/active, 1 = closed, 2 = expired or fulfilled, 3 = cancelled, 4 = pending, 5 = character deleted)
  • typeId – id of the item
  • range – range of the order (-1 = station, 0 = solar system, 5/10/20/40 jumps, 32767 = region)
  • accountKey – which division this order is using as its account; always 1000 for characters, but in the range 1000 to 1006 for corporations
  • duration – order duration in days
  • escrow – ISK in escrow
  • price – current price
  • type – order type (0 – buy, 1 – sell)
  • issued – date of being issued (UTC Date object)
  • firstSeen – date of being first seen by Evernus (UTC Date object)
  • lastSeen – date of being made inactive as seen by Evernus (UTC Date object)
  • corporationId – id of corporation of the issuer (due to QtScript limitation, stored as a string)
  • cost – custom cost (if set; not present otherwise; since 1.47)

Additionally, when used with filtering, there also is the overbid property representing the closest external order, which is an object of type ExternalOrder with additional properties:

  • diff – difference between character order and external order with sign depending on the type of order
  • diffRatio – the difference divided by character order price
  • normalizedDiff – difference between character order and external order with normalized sign

ExternalOrder object

The object contains these properties:

  • id – order id (due to QtScript limitation, stored as a string)
  • type – order type (0 – buy, 1 – sell)
  • typeId – id of the item
  • stationId – id of the station where the order originated
  • solarSystemId – id of the solar system where the order originated
  • regionId – id of the region where the order originated
  • range – range of the order (-1 = station, 0 = solar system, 5/10/20/40 jumps, 32767 = region)
  • updateTime – time of update (UTC Date object)
  • price – current price
  • volumeEntered – initial volume
  • volumeRemaining – remaining volume
  • minVolume – minimum volume
  • issued – issued date
  • duration – duration in days

Global functions

The following global object functions are available:

String EveDataProvider.getTypeName(typeId)

Returns the name of given item type.

String EveDataProvider.getLocationName(locationId)

Returns the name of given location (station).


Text filters

Every text filter supports wildcard syntax with history:

  • Any character represents itself apart from those mentioned below, ignoring case. Thus c matches the character c and C.
  • ? matches any single character.
  • * matches zero or more of any characters.
  • […] – sets of characters can be represented in square brackets, eg. [abc].

Source code compilation (Windows)

To compile Evernus on Windows, you’ll need Visual Studio 2017. Make sure you have all the prerequisites downloaded. Assuming you installed Qt to c:\Qt and Boost to c:\Boost, you have to invoke cmake to generate Visual Studio solution from VS command prompt, like so:

cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_PREFIX_PATH=c:/Qt/5.11/msvc2017_64/lib/cmake -DBOOST_ROOT=c:/Boost

Then just hit F7 and you’re good to go!

Source code compilation (Linux)

Before starting to compile the code, make sure you have installed all the prerequisites. The following manual assumes you have clang set as your c++ compiler, all the required libraries available in the system and Qt installed via their installer in your home directory.

First you have to generate a Makefile. This is done by invoking the cmake tool. If you don’t know what cmake is, you can read about it here. The simplest way is by using the console. For example, let’s assume you downloaded Qt 5.11 prebuilt with gcc:

cmake -G "Unix Makefiles" -DCMAKE_PREFIX_PATH=/home/$USER/Qt/5.11/gcc_64/lib/cmake

This will generate a Makefile for use with make (assuming no errors). Note, that this is a step you should be doing just once. The only thing left to do is:


And that’s it! Evernus should compile without errors. The resulting binary MUST reside in the same directory where the res/ and trans/ subdirectories are located, otherwise Evernus won’t be able to open Eve database and translations.

Source code compilation (OS X)

Before starting to compile the code, make sure you have installed all the prerequisites. For creating your own OS X bundle you have to build Qt frameworks which will be later imported into the app. You can do that by giving -framework to Qt configure command (remember to apply required patch to QXmlPatterns):

./configure -opensource -confirm-license -framework -prefix $PWD/qtbuildframeworks -nomake tests -nomake examples -release -skip qtwebkit 

You can also see couple of additional options here:

-prefix $PWD/qtbuildframeworks 

will help us to gather all frameworks and required files in one place.

-skip qtwebkit 

this will skip WebKit compilation which is a rather long process.

Once you are done configuring you can compile with make and install Qt to set prefix with make install. Once you are done with Qt you can start building Evernus. First you have to generate a Xcode project. This is done by invoking the cmake tool. If you don’t know what cmake is, you can read about it here. The simplest way is by using the console. For CMAKE_PREFIX_PATH you need to use the path you have provided to -prefix option of Qt configuration. Let’s assume you have downloaded Qt 5.11 sources and used configuration command above.

cmake -G "Xcode" -DCMAKE_PREFIX_PATH=/Users/$USER/Downloads/qt-everywhere-opensource-src-5.11/qtbuildframeworks 

This will generate an Xcode project file inside Evernus source directory.

The last step is to compile and bundle the application. You can compile with:

xcodebuild -project Evernus.xcodeproj 

Don’t mind the errors given from Xcode – it should compile properly; this is because Xcode cannot parse multiline strings. And finally bundle with:

 xcodebuild -project Evernus.xcodeproj -target install 

Remember about the last command because as the app bundle is created with previous command, all the dependencies are moved into the bundle in this step. And you are ready to go!

Source code compilation (all)

If you want Eve ESI or Dropbox support, you need to register your application on their respective developer webpages.

Eve SSO client id/secret has to be specified as constants/defines for cmake in order to work. These are:


The callback is

Dropbox id/key are similar:


The should be given (usually only once) as arguments for cmake:


If you don’t want to use Google Breakpad, you can turn this off from cmake:



Evernus comes with Dockerfile which you can use to build and run the application. Note – depending on your host system, you might need to forward some devices to make rendering work.

You can use the official Docker image: krojew/evernus – see the description for details.

Restoring database backup

Update process creates a database backup, which can be restored in case something goes wrong. You can find it in the c:\Users\your_user\AppData\Local\\Evernus\db directory on Windows, or ~/.local/share/ on Linux, named main.db.bak. Simply rename it to main.db and the backup will be restored.