Posted: -

The Fed is starting its massive balance sheet unwind. Given the current economic recovery and inflationary pressures, higher yields need to be paid on those treasuries in order to entice new holders. Last week the bond auction was already met with lukewarm demand, triggering the 10-year yields to reach a 4 year high.

Many market players had anticipated this moment, but the speed and magnitude of rate rises might surprise. Volatility is back.

Therefore, measuring the impact of a rate rise in your portfolio is critical at this juncture.

Most risk systems approach this somewhat simplistically: a rate rise propagates only to fixed income securities that depend on rates for their pricing. Equities would not show any PL impact.

Conversely, more sophisticated systems have the capability to propagate the rate risk to all securities in the portfolio. These systems are called transitive.

Everysk is transitive. It computes how an exogenous (or endogenous) shock propagates to ALL securities in the portfolio. The math and calculations to do so are not trivial. The computational power to quickly crunch these numbers is also significant.

Below, we show how a 1% rate hike in the 10 year treasury would instantaneously impact $1 invested in each security:

Security Expected P&L
GS +7.18%
XLI -0.26%
CORP:CATM 20220801 5.125 89 -2.16%
IBM -3.03%
NESN:XVTX (CHF investor) -9.43%
NESN:XVTX (USD investor) -12.16%
XLU -12.82%

Some remarks on the table above:

  • As expected, the utilities ETF (XLU) has a larger negative PL impact from a rate hike, compared to the industrials ETF (XLI)
  • Banks (GS) tend to benefit from higher rates
  • The swap above pays fixed, receives floating and therefore benefits from higher rates, which is captured via Libor vs. Treasury correlation
  • Nestle, traded in Europe has a higher risk for a USD investor. The USD tends to appreciate against other currencies when treasuries sell-off. The investor with USD as base currency is effectively short USD as her/his money is parked in a Swiss Franc asset. Everysk captures all the currency effects in the results.

To understand our symbology, please refer to: Symbology.

To review our supported global exchanges please refer to: Supported Exchanges.

It is trivial to check the impact of a rate hike in your own portfolio using our REST API. Please visit us at:

Posted: -

We are pleased to announce the launch of our REST API V2. V2 is a powerful upgrade in terms of functionality and performance. Its most salient features are:

  • Efficiently performs risk aggregation (bottom-up) and factor analysis (top-down) in a single API call.
  • Ability to supply forecasts for certain positions: these forecasts can represent outcomes that are difficult to be captured by market information, such as: a takeover situation, a pharmaceutical company clearing a drug trial or even a large correction not observed in the recent past.
  • Ability to supply your own volatility surface for accurate option simulations.
  • Ability to specify absolute (not percent) shocks on rates and spreads.
  • More powerful exception handling of securities that cannot be mapped to our symbology.
  • New documentation system and landing page.

Please contact us if you are interested on learning more about the API and its use cases.

Posted: -

Now when you sign in to your Dashboards account and navigate either to the description of plans or to the support page you will have access to a chat icon in the lower right corner:

Type any question and an Everysk representative will provide answers right away.

Posted: -

This blog demonstrates some properties from our fixed income asset classes. Specifically we will show how Everysk can capture intricate correlation effects between a corporate bond and a credit default swap.

First, let’s build a portfolio in Dashboards containing $1M face of a hypothetical 5 year bond issued by Chesapeake and a hypothetical 5 year CDS.

Security Quantity
CORP:CHK 20220628 6.77 100 $1,000,000
CDS:CHK 20220628 P5 $1,000,000

The corporate bond above matures on june 2022, has a 6.77% coupon and is priced at par. The CDS has the same maturity and buyer of credit protection pays 500 basis points annually. See all supported symbology here.

By stress testing this portfolio against a credit index, such as the Merrill Lynch US Corporate Bond BB Total Return Index, we get the following expected PL (for a 2% drop, which is in the range of weekly movements that this index can experience):

Portfolio CDS Bond
Expected Value (EV) 0.06% 0.76% -0.70%

We can see that the risk of the portfolio is largely hedged.

A more interesting stress test that captures some correlated effects is to shock the SP500. Below, we include a dynamic visualization whereby SP is being shocked from -1.2% (leftmost grey bar) to +1.2% (rightmost grey bar). This range is automatically calculated by Everysk and reflects the expected range of SP moves in a week:

The leftmost bar is highlighted to show it is the “active” bar. Move your mouse over the bar and you will be able to see the expected PL for the portfolio in that scenario, 0.22%. We also show low probability, high impact positive profit and loss (PL) of +1.09% and negative of -0.67%. These extreme PLs, specially the negative one, are generally called Conditional Value at Risk (CVaR) or expected shortfall. Then move the mouse over the 2 securities on the right: in a scenario of SP falling 1.2%, the corporate bond tends to lose money and the CDS tends to make. The contributions from each security to the overall portfolio properties are shown when you move the mouse over the securities. The summary is provided below:

Portfolio CDS Bond
CVaR+ 1.09% 0.76% 0.33%
EV 0.22% 0.47% -0.25%
CVaR- -0.67% 0.05% -0.72%

To visualize what happens when SP is up, just unselect the leftmost bar by clicking on it and then click on the rightmost bar. As you move your mouse over the other scenarios, you will realize that the right visualization changes accordingly. The summary for a +1.2% SP shock:

Portfolio CDS Bond
CVaR+ 0.68% -0.49% 1.16%
EV -0.21% -0.66% 0.45%
CVaR- -1.15% -0.90% -0.25%

So why is that the the CDS is expected to make more money (+0.47%) when the markets drops than the corporate bond is expected to lose (-0.25%), if the payer CDS is an exact short of the bond?

The main reason for this (expected) behavior is that corporate bonds have a credit spread risk factor that is positively correlated to the markets and an interest rate risk factor that is negatively correlated with the markets. When the markets are falling, the rate sensitivity helps immunize some of the pain, which is not present in the CDS. Therefore the CDS is expected to make more money. Conversely, when the markets are up the reverse happens: CDS is expected to lose more money (-0.66%) than the bond makes (+0.45%).

We can easily eliminate the interest rate effect described above by adding a payer swap to the portfolio:

Security Quantity
CORP:CHK 20220628 6.77 100 $1,000,000
CDS:CHK 20220628 P5 $1,000,000
SWAP:US 20220628 P1.77 $1,000,000

The resulting behavior for SP500 shocks would be:

We have largely eliminated the behavior (note small value for grey bars).

Capturing these correlated effects via visualizations can be a powerful metaphor to engage an existing and/or prospective client. You can find some code that replicates these results using our PortEngine API here. Check the symbology of fixed income securities here.

Posted: -

We are happy to announce the release of our fixed income asset class library. It is comprised of 7 new instruments, all sharing common risk elements:

The new fixed income asset classes and their respective symbology prefix are:

  • Convertibles (CONV:)
  • Exchangeables (EXCH:)
  • Term Debt (LOAN:)
  • Corporate Bonds (CORP:)
  • Government Bonds (GOV:)
  • Credit Default Swaps (CDS:)
  • Interest Rate Swaps (SWAP:)

The above schematic illustrates the risk factors that are simulated for each security. For example: for convertibles, we simulate rate risk, spread risk and convertibility risk (underlying stock risk). We also need to simulate FX risk when the security currency is different from the base currency of the portfolio (FX risk not shown in the schematic above).

Some salient features for the remaining securities:

  • For corporate bonds we simulate rate and spread risk (convertibility risk is greyed out).
  • For Government bonds we simulate rate risk and keep country spreads constant.
  • Term loans have limited rate rate risk and no convertibility.
  • CDS has pure spread (credit) risk.
  • Interest rate swaps has pure rate risk.

The prefix inside each box is used for specify the security. For example: CONV:AMD 20250901 2.5 140 78.0 is our symbology for Advanced Micro Device’s convertible expiring on September 2025, with a 2.5% coupon, priced at $140 and with a strike price of $78. See all supported symbology here.

These 7 new securities are fully integrated with the existing 10, namely: FX forwards, FX options, index options, future options, equity options, futures, global stocks, ETFs, mutual funds and indices. Furthermore our multi-asset, multi-currency calculation engine captures the correlated nature of all these assets.

Posted: -

Most money managers currently lack an efficient way to test the impact of new trades prior to executing them. The various systems available in the market are large deployments that were not designed for these type of on-the-flight, exploratory analytics.

Thus, if you want to quickly test how the addition of those SPY put contracts might affect the portfolio downside in a market shock, as a for instance, you might be out of luck.

In what follows we will show how what-if analysis can be performed effortlessly in Everysk Dashboards, in just 3 steps:

Step 1: Create a clone of the portfolio

In My Portfolios tab, drag and drop the portfolio you are interested to perform what-if analysis to the central panel. Then, in the right panel, you will see a new icon to create the clone:

Step 2: Edit the clone

When you click the button from Step 1, an editor with all properties and positions will open (see figure below):

Here you can quickly change many properties of the original portfolio, such as name, date, base currency and net asset value. Additionally, you can easily modify the contents of the original portfolio as follows:

  • To remove positions, just select them and click on the trash icon at the end of the list.
  • To change a position quantity, just edit the Contracts/Shares field(s)
  • To add a new position, just click on the button +Add Position

The image above illustrates a portfolio with 100 shares of Apple and 100 shares of Facebook that has been cloned. A new hedge was added to the portfolio, consisting of 1 at-the-money put option on SPY.

Step 3: Compare Original and Clone

Finally you can superimpose the original and clone with a template such as Stress Test Comparison

The unhedged portfolio is the light green and the portfolio with the put option is the dark green. Portfolio/Wealth managers can quickly ascertain the expected behavior of the trade just before executing it. All the process takes a few seconds from beginning to end.

Posted: -

This post explains in detail how we account for short positions. To understand shorts, we really should start with longs. Suppose a portfolio manager has a hypothetical single-stock portfolio with 100 shares of IBM. As an example, Everysk might produce a distribution of future profit and loss (PL) for the stock with a minimum PL of $-300, a maximum of $450 and an expected PL is $50.

Considering that IBM costs $180/share, $18000 will be necessary to generate the distribution of PL above. In order to convert the dollar PLs to percent amounts, all we need to do is divide them by $18000 (which is the net asset value, NAV, of this single-stock portfolio).

But, what happens if the same illustrative single stock portfolio was short 100 shares of IBM, instead of long? The distribution of profit and loss would simply be the flip side of the above, namely: a minimum of $-450, a maximum of $300 and an expected PL of $-50. How about the percentage distribution? What is the NAV to use as the denominator in the calculations?

The answer will largely depend on how much margin will be encumbered to enter the short. If Regulation-T applies, the investor will be required to have an end of day margin of at least 50% of the full value of the short. Thus, in this example, the investor would be required to have $9000 encumbered. The PL variability in percent would be larger than the long example (the distribution of PL would be divided by $9000).

To complicate matters, many investors might opt for a different margin calculation such as “portfolio margin”. This margin mechanism is a risk based measure that tends to benefit investors with offsetting positions, requiring less money to be set aside.

So, instead of second guessing how the encumbered margin amount is calculated for our clients, we provide 2 ways for that information to be explicitly supplied, as follows:

Method 1: Providing a NAV for the portfolio

Providing a net asset value explicitly (we call it net liquidating value here at Everysk). This can be done when the portfolio is imported into Dashboards:

Basically, all the PL calculations in a base currency will be divided by the provided NAV (which presumably includes the margin amounts) rather than an NAV calculated by Everysk (which only includes the cash account).

Method 2: Providing a margin amount

Instead of an explicit NAV, this method requires an explicit margin. Everysk has an instrument for this, margin:

The picture above shows the specification of an explicit margin amount. Both methods will produce the same percent risk statistics.

Posted: -

This blog post illustrates how to build a Google Sheets “front end” that is integrated with PortEngine, our REST API. Our calculation engine generates JSON responses that need to be visualized somehow. We describe a simple way to programatically write the portfolio results into a Google Sheets.

We will use a library called gspread. We follow closely the recipe described here.

One step that is not clear in the recipe above is that you will need to share the Google spreadsheet, which we called portOutput, with the email contained in the json file under ‘client_email’ key.

The main function is very simple:

def main():
    tickerlist= {
            'id1': ['IBM', 85, ''],
            'id2': ['AAPL', 130, ''],
            'id3': ['CVX', 100, ''],
            'id4': ['GS', 50, ''],
            'id5': ['F', 150, ''],
            'id6': ['MMM', 30, '']

    worksheet = getSheet('portOutput')

This function performs 2 simple tasks, namely: 1) authorizes the user with the proper service account key (see how to get one here) to read/write to the google spreadsheet in the cloud; and 2) performs stress tests using PortEngine and writes results to the spreadsheet.

The function to authorize user credentials is described below:

def getSheet(name):
    json_key = 'gspread_key.json'
    scope = ['']
    credentials = ServiceAccountCredentials.from_json_keyfile_name(json_key,scope)

    gc = gspread.authorize(credentials)
    wks =
    worksheets = wks.sheet1
    return worksheets

The function that performs a stress test in the portfolio for a -5% shock in the SP500 and writes results to the spreadsheet is described below:

def test_st_projection(tickerlist,worksheet):
    api_method = 'st_projection'

    # make a projection list with value and growth indices
    projection_list = ['IND:RLV', 'IND:RLG']
    args = {
        'date': '20161220',
        'shock': 'SPY',
        'magnitude': -0.05,
        'projection': projection_list
    args['tickerlist'] = tickerlist

    req = api.APIRequestor(cfg.API_SID, cfg.API_TOKEN, cfg.API_ENTRY, cfg.API_VERSION)
    ret = req.request(api_method, args)
    if ret['status'] != 200:
        raise api.APIError(ret)

    # Pre-processing
    projections = ret['response']['values']
    cvarneg_proj     = [i['cvarneg'] * 100.0 for i in projections]
    cvarpos_proj     = [i['cvarpos'] * 100.0 for i in projections]
    ev_proj          = [i['ev'] * 100.0 for i in projections]
    factor_ids  = [i['id'] for i in projections]

    api_method = 'st_aggregation'
    ret = req.request(api_method, args)
    if ret['status'] != 200:
        raise api.APIError(ret)

    # Pre-processing
    aggregations = ret['response']['values']
    cvarneg_agg     = [i['cvarneg'] * 100.0 for i in aggregations]
    cvarpos_agg     = [i['cvarpos'] * 100.0 for i in aggregations]
    ev_agg          = [i['ev'] * 100.0 for i in aggregations]
    sec_ids  = [i['id'] for i in aggregations]

    # write projections
    sz = len(ev_proj)
    table = [factor_ids,cvarpos_proj,ev_proj,cvarneg_proj]
    rg = range_a1((1,1),sz,len(table))
    cell_list = worksheet.range(rg)
    for rows in table:
        for i,val in enumerate(rows):
            cell_list[i+idx].value = val
        idx += sz

    # write aggregations
    sz = len(ev_agg)
    sec_tickers = getTickers(tickerlist,sec_ids)
    table = [sec_tickers,cvarpos_agg,ev_agg,cvarneg_agg]
    rg = range_a1((8,1),sz,len(table))
    cell_list = worksheet.range(rg)
    for rows in table:
        for i,val in enumerate(rows):
            cell_list[i+idx].value = val
        idx += sz

The above function performs the same -5% shock twice:

  1. The first time it calculates left tail risk (CVaR_neg), expected value (EV) and right tail (CVaR_pos) per factor. In the example, the code specifies an on-the-fly 2-factor model with value and growth indices (PortEngine calculates the contribution from these 2 factors plus residual to the portfolio’s properties). Thus the final matrix, including titles, has 4 rows by 3 columns. Summing the rows retrieves the portfolio CVaR-, EV and CVaR+
  2. The second time it calculates the contribution from each security to the same portfolio properties above. The matrix that is written to the spreadsheet has 4 rows and 6 columns, one per security:

Value and growth contributions to CVaR-,EV,CVaR+

All it takes is a few lines of code to output our calculations into a spreadsheet. For more information on our API look at: or send us a note to to request your API key. Refer to the full code for this post:

Posted: -

We could be approaching a point when it will be wise to diversify away from a purely US-centric portfolio. Others in the industry share this view:

“A lot of other markets have not done nearly as well [as the U.S.], and they look kind of cheap. So I think investors should think about diversifying, using this relative weakness in foreign markets to diversify away from the U.S.”, as stated by Jeffrey Gundlach here.

When you invest globally, foreign exchange plays a critical role on your risk/reward assessment. The relative performance of the foreign currency versus your base currency, under certain scenarios (oil down for example) can affect your portfolio in unforeseen ways. Not many systems can model the intertwining effects between currency and other assets the way we do.

We have posted several blogs covering how Everysk handles currency in the recent past. This current blog provides an index to all those posts, with a small blurb on each one:

March 16, 2016 - FX Effects -

This blog was our first write-up on how currencies are incorporated into equity simulations. We augment the covariance matrix with currency information, which is simulated as a log-normal process. This early post considered that the base currency of the portfolio was always in USD. Later on, we added functionality to make base currency an user-defined field.

March 17, 2016 - FX Factor Effects -

This blog described how a cross-sectional factor model would take currency into account. Generally it has to proceed in 2-steps:

  1. Measure the total portfolio exposure to factors
  2. Measure each factor Beta to the currency we are interested

We described how the mapping to factors makes the system less granular to monitor currency risks.

September 9, 2016 - Base Currency -

After a few months without writing about FX, we returned with a post describing a new feature, the flexibility to change the base currency of the portfolio to any one of the 40 available currencies.

We provided an illustrative example of how Everysk simulates the currency rates with other assets to incorporate critical correlation information that would otherwise be lost.

September 21,2016 - Currency Oil effects -

This blog provided a step-by-step guide on how to use Dashboards to find the asnwer to the following question: “An institutional investor in Europe wants to increase her/his emerging markets exposure. Investment opportunities in India and Brazil are being contemplated. Given that this investor is bearish on oil, which country is more vulnerable?”

October 20, 2016 - Broker Financing -

This blog describes the subtle effects of purchasing a foreign stock with broker financing and/or outright purchase.

November 2016 - Trump Stress Tests -

This blog post shows what market moves we forecasted on November 8, given a large MXN decline. Our conditional forecasts are very close to realized moves on those assets.

These 6 posts summarize our granular approach to modeling FX in Everysk. Please contact us at if you would like to learn more about your own currency risks going forward.

Posted: -

This post is an illustrative example on how to use PortEngine, our REST API, to compare your portfolio with a hypothetical portfolio with same stocks, but with different allocations reflecting equal risk contributions (ERC). ERC, also called risk parity, is a portfolio whereby all positions have the same marginal contribution to total risk. This approach has experienced phenomenal growth and has been advocated by important investors, most notably Bridgewater and Panagora. See interesting article here.

The second step of this example involves comparing the expected shortfall (CVaR-) for both portfolios, for a 5% shock in the SP500 and dissecting the contribution from value and growth factors to that shortfall risk. This is not a trivial calculation as we want to project the portfolio’s left tail risk to a factor model, conditional on a specific shock. We will show how this can be easily achieved using PortEngine.

Why: Comparing how both portfolios react to the same shock (in this case SP down 5%) will provide an apples-to-apples reading of how much equities risk we are assuming by deviating from ERC allocations. We will also show the contributions from value and growth factors to the left tail risk changes.

Steps: a) Given a portfolio, find the equivalent ERC allocations using Scipy’s optimization module; b) Compute the difference in left tail risk from a SP 5% shock between the original portfolio and the ERC portfolio.

The simple code below will perform all calculations:

 def main():
    # read tickers from yahoo - retain last entry
    tickerlist = {
        'id1': ['IBM', 85, ''],
        'id2': ['AAPL', 130, ''],
        'id3': ['CVX', 100, ''],
        'id4': ['GS', 50, ''],
        'id5': ['F', 150, ''],
        'id6': ['MMM', 30, '']

    tickers = []
    shares = []
    for keys, values in tickerlist.iteritems():
    cov, data = buildCov(tickerlist)

    # find risk parity weights
    wtsERC = solveERC(cov.values)

    # convert weights in shares
    origNLV = np.sum(np.array(shares) * data[-1:].values)
    sharesERC = wtsERC * origNLV / data[-1:].values

    # assemble a new tickerlist with ERC shares
    idx = 0
    erc_tickerlist = {}
    trades = {}
    for keys, values in tickerlist.iteritems():
        erc_tickerlist[keys] = (values[0], sharesERC[0][idx], '')
        trades[values[0]] = sharesERC[0][idx] - values[1]
        idx += 1

    # call PortEngine
    leftTail, delta_leftTail = compare_ST(tickerlist, erc_tickerlist)
    print trades
    print delta_leftTail

The first function called, buildCov, simply builds a covariance matrix using Adjusted closing prices for the last 2 years. We use functions from Pandas library:

def buildCov(tickerlist):
    start = datetime.datetime(2015, 1, 1)
    end = datetime.datetime(2016, 12, 20)
    tickers = [t[0] for t in tickerlist.values()]
    data = web.DataReader(tickers, 'yahoo', start, end)['Adj Close']
    data = data[tickers]
    ret = np.log(data / data.shift(1))[1:]
    cov = ret.cov()
    return (cov, data)

The next function takes a covariance matrix and computes the weights reflecting equal risk contribution, i.e. each position has the same marginal contribution to total risk:

def solveERC(S):
    J, K = S.shape
    initW = np.ones((J, 1)) / J
    bnds = ((0, 1),) * J
    cst = prepare_constraint(J)
    res = minimize(riskParity, initW, constraints={'type': 'eq', 'fun': cst}, bounds=bnds, args=(S,), method='SLSQP', tol=1e-6, options={'disp': True})
    return np.array(res['x'])

The function above makes a call to Scipy’s optimization module. The objective function, riskParity is defined below:

def riskParity(wts, S):
    N, M = S.shape
    portRisk =,, S))
    mctr = wts *, wts)
    mctr = mctr / portRisk
    accum = 0.0
    for i in xrange(0, N):
        for j in xrange(i + 1, N):
            delta_mctr = mctr[i] - mctr[j]
            accum += delta_mctr * delta_mctr
    return 2.0 * accum

By minimizing this objective function we are minimizing the differences on marginal contribution to total risk from each position.

The following function establishes that weights should add to 100% (Caveat: this illustrative code will work with long only portfolios):

def prepare_constraint(J):
    ones = np.ones((1,J))
    constraint = lambda x: 1.0 -, x)
    return constraint

Finally we can call PortEngine with 2 tickerlists, the original and the new one reflecting ERC:

def compare_ST(tickerlist, erc_tickerlist):
    api_method = 'st_projection'

    # make a projection list with value and growth indices
    projection_list = ['IND:RLV', 'IND:RLG']
    args = {
        'date': '20161220',
        'shock': 'IND:SPX',
        'magnitude': -0.05,
        'projection': projection_list
    args['tickerlist'] = tickerlist
    req = api.APIRequestor(cfg.API_SID, cfg.API_TOKEN, cfg.API_ENTRY, cfg.API_VERSION)
    ret = req.request(api_method, args)
    if ret['status'] != 200:
        raise api.APIError(ret)

    # Pre-processing
    projections = ret['response']['values']
    cvarneg = [i['cvarneg'] * 100.0 for i in projections]
    cvarpos = [i['cvarpos'] * 100.0 for i in projections]
    ev = [i['ev'] * 100.0 for i in projections]
    factor_ids = [i['id'] for i in projections]

    # Portfolio CVaR-, EV and CVaR+ for the specific shock:'
    port_CVaRNeg = fsum(cvarneg)
    port_EV = fsum(ev)
    port_CVaRPos = fsum(cvarpos)

    # Contribution to portfolio EV, CVaR from Industrial and Energy sectors (%):'
    contrib_CVaRNeg = [(factor_ids[x], cvarneg[x]) for x in xrange(0, len(ev))]

    # Second call with erc tickerlist
    args['tickerlist'] = erc_tickerlist
    ret = req.request(api_method, args)
    if ret['status'] != 200:
        raise api.APIError(ret)

    # Pre-processing
    projections = ret['response']['values']
    erc_cvarneg = [i['cvarneg'] * 100.0 for i in projections]
    factor_ids = [i['id'] for i in projections]

    # Portfolio CVaR-, EV and CVaR+ for the specific shock:'
    erc_port_CVaRNeg = fsum(erc_cvarneg)

    # Contribution to portfolio EV, CVaR from Industrial and Energy sectors (%):'
    delta_CVaRNeg = [(factor_ids[x], (cvarneg[x] - erc_cvarneg[x])) for x in xrange(0, len(ev))]
    leftTail = (port_CVaRNeg, erc_port_CVaRNeg)
    return (leftTail, delta_CVaRNeg)

The first few lines from the code above specify an on-the-fly factor model with value and growth indices (residual will be computed by PortEngine):

    api_method = 'st_projection'
    # make a projection list with value and growth indices
    projection_list = ['IND:RLV', 'IND:RLG']

Then we proceed to compute the expected shortfall (CVaR-) for the original portfolio as well as the ERC allocations. The code returns all the deltas to show which portfolio is more vulnerable to an US equities shock. Granular details about the composition of the deltas in terms of value/growth explanatory power is also returned.

All it takes is a few lines of code. For more information on our API look at: or send us a note to to request your API key. Refer to the full code for this post: