Home
Blog
Brazil ETF VIX 1m (VXEWZ) Price Change API

Brazil ETF VIX 1m (VXEWZ) Price Change API

Brazil ETF VIX 1m (VXEWZ) Price Change API

You need to monitor the 1‑minute Brazil ETF VIX (VXEWZ) and trigger actions when it moves—alert a Slack channel, update a dashboard sparkline, or backfill the latest reading for a quant pipeline. By the end of this guide you will query the VXEWZ latest value, understand how to interpret the fields for price and inverse price, and wire up a clean “price change since prior close” calculation using Indices‑API endpoints that are built for this job.

What we will build: a reliable VXEWZ price-change check

This walkthrough focuses on a minimal—but production-ready—flow:

Illustration: Brazil ETF VIX 1m (VXEWZ) Price Change API
  • Fetch the latest VXEWZ quote via the latest endpoint.
  • Interpret the two relevant rates fields (VXEWZ and USDVXEWZ) correctly relative to the USD base.
  • Use the fluctuation endpoint to compare yesterday’s close to the last available reading, then compute change and percent change on your side without inventing numbers.
  • Harden your integration around update cadence, weekends, and caching.

If you need a symbol reference or to confirm coverage, see the up-to-date catalog on the Indices‑API Supported Symbols page. The VXEWZ ticker is used throughout this article.

Endpoints we will use

We’ll keep this tight and use only what’s necessary for VXEWZ price change:

  • Latest: to get the most recent VXEWZ reading and its inverse (USDVXEWZ).
  • Fluctuation: to obtain the start and end rates for a given window (e.g., yesterday versus today’s last available reading), which you’ll use to compute absolute and percent change in your app.

For details on all available endpoints and parameters, consult the Indices‑API Documentation. If you don’t yet have credentials, you can start with a 7‑day trial on the PRO plan ($49.99/mo) here: Register.

How VXEWZ is quoted: base, rates, and inverse

Indices‑API responses are quoted relative to a base currency. By default, base is USD. In this convention:

  • rates.VXEWZ is “how many VXEWZ units one USD buys.”
  • rates.USDVXEWZ is the inverse: “how many USD per one VXEWZ unit.”

Many developers prefer to chart or alert on “price per VXEWZ unit in USD.” If that’s you, use rates.USDVXEWZ directly. If your math expects the base-quoted format (VXEWZ per USD), use rates.VXEWZ. Both are provided so you can avoid manual inversion and floating-point edge cases.

One call: fetch the latest VXEWZ reading

Below is a complete curl you can paste to retrieve the most recent snapshot. Replace YOUR_API_KEY with your access key from the Indices‑API dashboard.

curl -s "https://indices-api.com/api/latest?access_key=YOUR_API_KEY"

Here is the real response format with a VXEWZ print. Use these exact field names in your integration:

{"data":{"success":true,"timestamp":1794271200,"date":"2026-11-10","base":"USD","rates":{"VXEWZ":0.03088326127239,"USD":1,"USDVXEWZ":32.38000000000038}}}

What these fields mean for your app

  • data.success: Boolean you should check before reading values.
  • data.timestamp: Unix epoch (seconds). Use it to determine staleness and for cache TTL decisions.
  • data.date: Calendar date of the snapshot in YYYY‑MM‑DD.
  • data.base: The currency everything is quoted against. Default is "USD".
  • data.rates.VXEWZ: VXEWZ units per 1 USD.
  • data.rates.USDVXEWZ: USD per 1 unit of VXEWZ (the inverse of rates.VXEWZ).

If your product displays a “price” line for VXEWZ, you’ll typically use data.rates.USDVXEWZ. If you’re doing conversions or relative math within a USD base context, data.rates.VXEWZ is the canonical rate.

JavaScript example: parse the latest VXEWZ and compute a price change vs prior close

This Node.js snippet does two things: (1) fetches the latest VXEWZ quote and (2) shows a simple pattern to compute change using the fluctuation endpoint without hardcoding any numbers in the article. You can adapt the URL building to your framework as needed.

import fetch from "node-fetch";

const API_BASE = "https://indices-api.com/api";
const ACCESS_KEY = process.env.INDICES_API_KEY || "YOUR_API_KEY";

// Utility: last business day helper (basic; adjust for holidays)
function getPrevBusinessDate(isoDate) {
  const d = new Date(isoDate + "T00:00:00Z");
  let off = 1;
  // Step back one day at a time until Mon–Fri
  while (true) {
    const back = new Date(d.getTime() - off * 86400000);
    const dow = back.getUTCDay();
    if (dow !== 0 && dow !== 6) {
      return back.toISOString().slice(0, 10);
    }
    off += 1;
  }
}

async function fetchLatestVXEWZ() {
  const url = `${API_BASE}/latest?access_key=${ACCESS_KEY}`;
  const res = await fetch(url);
  if (!res.ok) throw new Error("latest request failed");
  const payload = await res.json();
  const data = payload.data || payload; // handle envelope
  if (!data.success) throw new Error("latest success=false");
  const { timestamp, date, base, rates } = data;
  const v_per_usd = rates["VXEWZ"];     // VXEWZ units per USD
  const usd_per_v = rates["USDVXEWZ"];  // USD per VXEWZ unit
  return { timestamp, date, base, v_per_usd, usd_per_v };
}

async function fetchFluctuationVXEWZ(startDate, endDate) {
  // end_date cannot be today; pass the latest completed trading day
  const url = `${API_BASE}/fluctuation?access_key=${ACCESS_KEY}&start_date=${startDate}&end_date=${endDate}`;
  const res = await fetch(url);
  if (!res.ok) throw new Error("fluctuation request failed");
  const payload = await res.json();
  return payload;
}

(async () => {
  const latest = await fetchLatestVXEWZ();
  // Pick a completed end_date: if latest.date is still "today" and markets are active,
  // you can use latest.date for display but choose yesterday for fluctuation calculations.
  const endDate = getPrevBusinessDate(latest.date);
  const startDate = getPrevBusinessDate(endDate);

  // Fluctuation returns start_rate and end_rate you can use to compute change and pct
  const fl = await fetchFluctuationVXEWZ(startDate, endDate);

  // Example: read the VXEWZ portion safely if present
  const vx = fl && fl.rates && fl.rates["VXEWZ"] ? fl.rates["VXEWZ"] : null;

  const currentUsdPerUnit = latest.usd_per_v; // display-friendly price
  console.log({
    base: latest.base,
    timestamp: latest.timestamp,
    latest_date: latest.date,
    usd_per_vxewz: currentUsdPerUnit,
    // Use vx.start_rate and vx.end_rate (if available) to compute change on your side
    // without hardcoding any sample numbers here.
    fluctuation_window: { startDate, endDate },
    vxewz_fluctuation: vx
  });
})().catch(err => {
  console.error(err);
  process.exit(1);
});

This example keeps the two calls separate so you can cache the latest response (short TTL) and the fluctuation response (longer TTL) independently.

How to compute “price change” correctly

With fluctuation you’ll receive, for VXEWZ, an object that includes start_rate and end_rate for your date window. In your app:

  • Absolute change = end_rate − start_rate (use either VXEWZ-per‑USD or USD‑per‑VXEWZ consistently; do not mix).
  • Percent change = (end_rate − start_rate) / start_rate.

Do not attempt to compute percent change by mixing rates.VXEWZ with rates.USDVXEWZ; pick one representation and stick to it across start and end. If you prefer “price per VXEWZ unit,” base your math on USDVXEWZ for both days.

Important: end_date cannot be today. Use the most recent completed trading day as your end_date. If you need an intraday delta, compare the latest USDVXEWZ to yesterday’s close (end_rate from fluctuation) and compute your change locally.

Trading days, weekends, update cadence, and caching

Practical details that save time in production:

  • Trading days vs weekends: VXEWZ won’t update on weekends and certain holidays. If data.date is a non‑trading day, expect it to be the last business date.
  • Update frequency: depending on your subscription tier, latest data updates at intervals such as every 60 minutes or every 10 minutes. Polling faster won’t yield newer data and just wastes calls.
  • Caching: honor the timestamp field as your truth. If timestamp hasn’t advanced, you can serve from cache. A 30–90 second TTL is a practical baseline for server caches, then widen if your plan updates less frequently.
  • Time zones: timestamp is in Unix seconds; treat it as UTC. Align this with your job schedulers and chart labels to avoid local‑time drift.
  • end_date cannot be today: always pick a completed date for fluctuation and time‑series queries.

From latest to charts: using time windows

For intraday or multi‑day charts, pair the latest endpoint with either the fluctuation endpoint (for summarized change over a range) or time‑series (for daily historical rates). Keep in mind:

  • Time‑series gives daily points between start and end dates you choose. This is ideal for backfills and daily charts.
  • Fluctuation summarizes the delta between two dates with start_rate and end_rate, which is perfect for “since last close” banners and compact KPI widgets.

If you need to verify that VXEWZ supports the granularity you want, consult the Indices‑API Documentation and confirm the exact symbol on the Indices‑API Supported Symbols list.

Error handling and resilience

Guardrails worth adding from day one:

  • Check data.success before reading rates. Abort gracefully on false and log payloads.
  • Null‑check rates.VXEWZ and rates.USDVXEWZ before computing change.
  • Always compare timestamps. If the timestamp is older than your tolerance, surface a “stale” badge in the UI rather than displaying misleading changes.
  • Retry with backoff on 5xx and network timeouts; do not spam retries faster than the update cadence.

Units recap and conversions

Indices‑API quotes are relative to a base currency (“base”: “USD” in our examples). This has two important consequences for VXEWZ developers:

  • rates.VXEWZ expresses VXEWZ units you get per 1 USD. It is a fractional number because VXEWZ units are larger than 1 USD.
  • rates.USDVXEWZ is the USD price of one VXEWZ unit. This is often what you chart or alert on.

You can switch between them by inversion, but since both keys are present in the same payload you should avoid recomputing and just use the field you need.

Security, deployment, and MCP integrations

Keep your access_key server-side and proxy client requests through your backend. For teams running a multi‑component platform, document your data contract around the five fields you actually use (success, timestamp, date, base, rates) to keep clients independent of upstream additions. If you orchestrate multiple providers, review the MCP resource for integration patterns and controls.

Operational checklists for VXEWZ alerts

  • Confirm symbol: VXEWZ must exist on the symbols registry; validate at startup against the Supported Symbols.
  • Choose your representation: USD per VXEWZ (USDVXEWZ) or VXEWZ per USD (VXEWZ). Use the same representation for both sides of any comparison.
  • Pick a sensible poll interval: align to your plan’s update frequency. If your plan updates every 10 minutes, poll every 10–12 minutes.
  • Use end_date that is not today when calling fluctuation or time‑series. If you need “intraday since prior close,” combine fluctuation for yesterday with latest for now.
  • Cache with a short TTL and revalidate conditional on timestamp progression to avoid redundant processing.

cURL and code recap

You can ship this in minutes. The only moving pieces are the latest call and the optional fluctuation window for your change math. Here are the essentials again:

  • Latest curl (copy/paste):
curl -s "https://indices-api.com/api/latest?access_key=YOUR_API_KEY"
  • Real JSON you should parse (fields listed exactly as returned):
{"data":{"success":true,"timestamp":1794271200,"date":"2026-11-10","base":"USD","rates":{"VXEWZ":0.03088326127239,"USD":1,"USDVXEWZ":32.38000000000038}}}
  • Use data.rates.USDVXEWZ as the display price, data.rates.VXEWZ if you prefer the base-quoted representation, and data.timestamp to control caching and staleness.

Additional references

FAQ

How often does VXEWZ update?
The latest endpoint refresh cadence depends on your plan tier (for example, intervals like every 60 minutes or every 10 minutes). Set your poll interval to match your plan’s update frequency and rely on the timestamp field to detect genuine updates.

Which field should I use for a “price” label?
Use rates.USDVXEWZ to display “USD per 1 VXEWZ unit.” If you prefer to keep values in the base convention, use rates.VXEWZ, which is “VXEWZ per 1 USD.” Don’t mix them when computing changes.

Why does fluctuation reject today as end_date?
The endpoint requires completed days. Use the most recent finished trading day as end_date. For an “intraday since prior close” widget, combine fluctuation (yesterday) with the latest endpoint (now).

How do weekends and holidays affect VXEWZ?
On non‑trading days, the latest date and timestamp won’t advance. Your app should tolerate repeated timestamps and keep using cached values until the next market session.

Can I confirm VXEWZ support and metadata?
Yes—verify VXEWZ on the Supported Symbols page before shipping to production.

Ready to wire up VXEWZ price change and alerts? Grab your key and ship an integration in under an hour with the latest and fluctuation endpoints: Register. For deeper endpoint behavior, examples, and edge cases, keep the Documentation open as you implement.

Ready to use Indices-API?

Try it now!

Search

Recent Posts