F1 Pre-season testing 2026: What to watch & how to track it

The testing schedule

The 2026 pre-season runs across three distinct blocks. The first was a private shakedown not organised by the FIA or Formula 1. The other two are official test weeks with public track time.

– Both Bahrain tests are three-day official test sessions where teams run their 2026 cars.
– Coverage varies by region and broadcaster. Some broadcasters show only limited hours; not all sessions are live everywhere.

Times and structure

– The standard daily testing window in Bahrain historically runs from around 10:00 to 19:00 local time, with a lunch break in the middle. Specific daily programme details are consistent with prior F1 testing formats.
– Teams can split driving time between two drivers as they choose during test days.

Why 2026 pre-season testing is different

For most seasons, pre-season testing is about refinement. Teams arrive with a known car architecture and use the days to adjust setups and better understand the tyre behaviour. They leave with a clearer picture of where they sit relative to the field.

2026 is not like most seasons.

The regulations have changed more extensively than at any point since the hybrid era began in 2014. Both the chassis and power unit rules have been rewritten, meaning pre-season testing is not just about refinement. It is the first opportunity every team has to run their 2026 cars in race-like conditions under the full set of new regulations.

The headline changes affect how the cars are designed and how they deliver power:

– No more DRS. The Drag Reduction System, which has been used for overtaking, is being retired. It is being replaced by active aerodynamics and related overtaking systems, in which elements of the front and rear wings can move to adjust drag and downforce dynamically.
– New overtaking and energy systems. Instead of DRS, there will be systems such as Overtake Mode, Boost and Recharge. These involve the deployment of additional electrical power and the management of recovered energy to help in overtaking and race situations, rather than relying on a fixed-wing flap as in the old DRS system.
– New power unit architecture. The MGU-H (heat energy recovery unit) is removed from the power units. The MGU-K (kinetic energy recovery unit) is significantly more powerful, and the power unit will use a more even split between electrical and internal-combustion outputs. These changes shape how teams manage energy over a lap and through a race weekend.
– New constructors and engine suppliers. The entry list for 2026 includes Audi taking over from Sauber as a works team, Red Bull Powertrains partnered with Ford, and Honda returning as Aston Martin’s engine supplier. Renault stops supplying engines, and Alpine switches to Mercedes power units. Cadillac enters as a new team, initially using Ferrari power units. All of these combinations are new under the 2026 regulations and lack baseline data for the current generation of cars.
– Smaller and lighter cars. The new cars are narrower and lighter than in previous years, with changes to the chassis and aerodynamic philosophy that alter their mechanical and aerodynamic behaviour.

Barcelona shakedown (Jan 26–30): What happened

The Barcelona shakedown was a private test arranged by the teams at the Circuit de Barcelona-Catalunya, not organised by Formula 1 or the FIA. It was held behind closed doors, with no official live broadcast or published timing, and limited media access. Its purpose was to allow teams to run their new 2026 cars in real track conditions for the first time, focus on reliability and basic systems checks, and gather early data ahead of the official Bahrain tests.

Williams did not participate in the Barcelona shakedown. The team chose to skip the event due to delays in completing their new car, instead focusing on preparation for the official Bahrain testing in February.

Teams were allowed to run on three of the five days according to their own schedule. Most teams took this opportunity to get meaningful mileage without major issues, concentrating on fundamental checks rather than outright performance.

What emerged publicly from the five days was limited and based on unofficial reports. Still, it suggested that the majority of teams completed a useful amount of running and did not suffer catastrophic failures. No official lap time data was released, and teams kept their detailed run plans private. The focus was more on reliability, installation laps and understanding the new cars than on revealing performance order.

At the end of the week, unofficial accounts indicated that several teams logged solid mileage and that the shakedown delivered early clues but no firm conclusions about the competitive order ahead of the Bahrain tests.

Bahrain Test 1 (Feb 11–13): First competitive signals

The first official Bahrain pre-season test provided the earliest publicly available running data for the 2026 season. With all 11 teams on track at the Bahrain International Circuit, this was the first time that a competitive context was possible after the private Barcelona shakedown.

Across the three days of running, timesheets and lap counts began to reveal how different cars and teams were coping with the new technical regulations. On the opening day, Lando Norris in the McLaren set the fastest time of the afternoon session with a 1 min 34.669 sec lap, narrowly ahead of Max Verstappen in the Red Bull and Charles Leclerc in the Ferrari.

As the test progressed, Mercedes emerged strongly on the final day, with George Russell and Kimi Antonelli topping the times on Friday. By the end of the test, the quick timesheets showed Mercedes first and second, followed by Ferrari and McLaren.

Red Bull was active and completed significant mileage throughout the test. Still, team sources cautioned that outright lap times at this stage are not a definitive measure of true performance, because fuel loads and programmes differ widely between teams during testing.

Teams with new engine partnerships and newcomer constructors put a large emphasis on reliability and long-run programmes rather than setting headline lap times. Audi and Cadillac logged substantial mileage as they accumulated data on their new cars, and Aston Martin’s early running was focused on completing laps and understanding energy and chassis behaviour under the new regulations.

Because official lap time data is not always representative during pre-season tests, performance trends should be treated with caution. The first Bahrain test, however, offered a first comparative indication of where teams roughly stand under the 2026 rules and highlighted the work still to be done ahead of the second Bahrain session.

Bahrain Test 2 (Feb 18–20): What to watch now

The second Bahrain test is the one that matters most for analysts, developers and fans building data tools. It is the final official test session before the Australian Grand Prix on 6 March, and unlike the first Bahrain test, every minute of track time is broadcast live on F1 TV and partner channels. This provides a much clearer picture of how teams are progressing under the new rules.

Here are the key areas to pay close attention to across the three days:

Long-run pace over single laps

By the second Bahrain test, most teams will shift from basic systems checks to longer runs that resemble race stints. Analysts look for consistent lap times over 20 or more laps on the same set of tyres with steady performance and limited degradation. A fast single lap can be misleading if it is on an ultra-light fuel load, but a consistent long-run pace is a stronger indication of potential race competitiveness. While exact team programmes are not fully public, this approach is understood to be the focus at this stage in testing.

Active aero in real conditions

The Bahrain International Circuit combines high-speed straights with slower technical corners, making it a demanding environment for the new active aerodynamic systems introduced in 2026. Observers will watch how cars handle through high-speed sections, especially in sector three, to see if teams have found suitable aero configuration maps and stable balance under different conditions. The new era of active aero replaces the retired DRS setup and is key to performance and overtaking potential.

Cadillac’s competitiveness benchmark

As the grid’s newest team, Cadillac gets its first extended test against the entire field. With no historical aerodynamic baseline and less time building its car, Cadillac is expected to start further back. Their rate of improvement across the test, in both lap times and lap counts, will show how quickly their technical programme is converging with the established teams. There are no official performance targets published, but mileage and development progress are widely treated as priority indicators at this stage.

Ferrari’s updates

Several teams are bringing upgrades to the cars for the second Bahrain test. Ferrari is reported to have introduced new parts or specifications for this session, giving them a chance to compare updated performance under more representative running conditions. Official team statements on specific upgrades are limited, but reports from coverage note that teams aim to trial revised aero and mechanical components in the second test.

Reliability under extended running

Reliability remains a core focus. In past major regulatory changes, teams that maintained uninterrupted testing have entered the season with fewer technical issues, while those with persistent failures have carried doubts into the opening rounds. With new power unit regulations and active systems, technical reliability over extended runs is particularly important. At the same time, specific failure data is not officially published from test sessions, and team behaviour and track stoppages observed during the week influence early impressions of reliability.

How to read pre-season testing data

Testing data can be misleading if you take it at face value. That is because teams use pre-season sessions in very different ways, with goals that are quite separate from simply setting the fastest lap time.

Fuel loads vary greatly

Lap times mean little without knowing how much fuel a car has on board. A car running a full tank for a long-run simulation will be much heavier than one doing a short qualifying-style lap. That weight difference can easily add two or more seconds per lap, even for the same car and driver, making comparisons based on times alone unreliable.

Tyre compounds are not standardised in public data

Teams are not required to declare which tyre compound they are running when a time is set. A long run on softer rubber will produce different lap times and degradation than a long run on harder tyres. Without knowing the compound and how it wears over time, absolute lap times are not directly comparable.

Not all sessions are equal

Early in any test, especially on the first morning, most teams concentrate on installation laps and system checks rather than performance running. Those initial sessions largely focus on making sure the car works as intended and that no glaring faults remain, so lap times from these periods tell you almost nothing about race pace.

Look for consistency, not peaks

The most reliable insights from testing are not who set the fastest lap. Instead, look at which teams:

– completed the highest number of laps without major issues, indicating good reliability;
– showed stable lap times over long runs, a sign of efficient energy and tyre management;
– displayed limited variance between shorter and longer runs, hinting at consistency rather than peak performance.

Testing is a data-gathering exercise, not a competition. Engineers use the data to validate wind-tunnel and simulator predictions, test components under real-world conditions, and work toward a car setup that performs well in race conditions.

Tracking it with the Sportmonks Motorsport API

The Sportmonks Motorsport API v3 is the data layer for everything we’ve described above. It delivers Formula 1 data in a consistent JSON format via REST endpoints, covering fixtures, live sessions, lap-by-lap timing, pit stops, tyre stints, driver and team profiles, and standings.

The base URL for all requests is:

https://api.sportmonks.com/v3/motorsport

// Option 1: Query parameter
const url = `https://api.sportmonks.com/v3/motorsport/fixtures?api_token=YOUR_TOKEN`;

// Option 2: Authorization header (recommended for production)
const response = await fetch('https://api.sportmonks.com/v3/motorsport/fixtures', {
  headers: {
    'Authorization': 'YOUR_TOKEN',
    'Accept': 'application/json'
  }
});

Fetch the testing fixtures

The starting point for any testing tracker is pulling the fixtures themselves. The /fixtures/between/{start}/{end} endpoint lets you scope your request to the testing window.

async function getTestingFixtures() {
  const API_TOKEN = 'YOUR_TOKEN';
  const startDate = '2026-02-11'; // Start of Bahrain Test 1
  const endDate   = '2026-02-20'; // End of Bahrain Test 2

  const url = `https://api.sportmonks.com/v3/motorsport/fixtures/between/${startDate}/${endDate}`
            + `?api_token=${API_TOKEN}&include=venue,stage,state`;

  const response = await fetch(url);
  const data     = await response.json();

  console.log('Testing sessions:', data.data);
  return data.data;
}

{
  "data": [
    {
      "id": 19618731,
      "sport_id": 2,
      "league_id": 3536,
      "season_id": 26736,
      "stage_id": 77479415,
      "group_id": null,
      "aggregate_id": null,
      "round_id": null,
      "state_id": 5,
      "venue_id": 343578,
      "name": "Day 1",
      "starting_at": "2026-02-11 07:00:00",
      "result_info": null,
      "leg": "1\/3",
      "details": null,
      "length": null,
      "placeholder": false,
      "has_odds": false,
      "has_premium_odds": false,
      "starting_at_timestamp": 1770793200,
      "venue": {
        "id": 343578,
        "country_id": 190321,
        "city_id": 4061,
        "name": "Bahrain International Circuit",
        "address": null,
        "zipcode": null,
        "latitude": "26.0325",
        "longitude": "50.5106",
        "capacity": 70000,
        "image_path": "https:\/\/cdn.sportmonks.com\/images\/core\/venues\/26\/343578.png",
        "city_name": null,
        "surface": "asphalt",
        "national_team": false
      },
      "stage": {
        "id": 77479415,
        "sport_id": 2,
        "league_id": 3536,
        "season_id": 26736,
        "type_id": 106731,
        "name": "Formula 1 Aramco Pre-Season Testing 1",
        "sort_order": 1,
        "finished": false,
        "is_current": true,
        "starting_at": "2026-02-11",
        "ending_at": "2026-02-13",
        "games_in_current_week": false,
        "tie_breaker_rule_id": 573
      },
      "state": {
        "id": 5,
        "state": "FT",
        "name": "Full Time",
        "short_name": "FT",
        "developer_name": "FT"
      }
    },

Get live session data

During an active testing session, the /livescores endpoint returns real-time information for all currently running fixtures.

async function getLiveSessions() {
  const API_TOKEN = 'YOUR_TOKEN';

  const url = `https://api.sportmonks.com/v3/motorsport/livescores`
            + `?api_token=${API_TOKEN}&include=state,participants,venue,laps.driver`;

  const response = await fetch(url);
  const data     = await response.json();

  data.data.forEach(session => {
    console.log(`LIVE: ${session.name} — ${session.state?.name}`);
  });

  return data.data;
}

// Poll every 30 seconds while a session is live
function startLivePolling(callback, intervalMs = 30000) {
  const poller = setInterval(async () => {
    try {
      const sessions = await getLiveSessions();

      if (sessions.length === 0) {
        console.log('No active sessions — stopping poller.');
        clearInterval(poller);
        return;
      }

      callback(sessions);
    } catch (err) {
      console.error('Polling error:', err);
    }
  }, intervalMs);

  return poller;
}

startLivePolling((data) => {
  console.log('Session update:', data);
});

Pull lap times by driver

Lap time data is the core of any meaningful testing analysis. The /fixtures/{fixture_id}/laps endpoint returns all recorded laps for a given session, and you can filter down to a specific driver using /fixtures/{fixture_id}/laps/drivers/{driver_id}.

async function getLapTimes(fixtureId) {
  const API_TOKEN = 'YOUR_TOKEN';

  const url = `https://api.sportmonks.com/v3/motorsport/fixtures/${fixtureId}/laps`
            + `?api_token=${API_TOKEN}&include=driver,team`;

  const response = await fetch(url);
  const data     = await response.json();

  return data.data;
}

function analyzeDriverConsistency(laps) {
  // Filter out in-laps, out-laps, and any laps with no recorded time
  const racingLaps = laps.filter(lap => lap.time && lap.time > 0);

  if (racingLaps.length === 0) return null;

  const times    = racingLaps.map(l => l.time);
  const fastest  = Math.min(...times);
  const average  = times.reduce((a, b) => a + b, 0) / times.length;
  const variance = times.reduce((sum, t) => sum + Math.pow(t - average, 2), 0) / times.length;
  const stdDev   = Math.sqrt(variance);

  return {
    driver:      racingLaps[0]?.driver?.name,
    totalLaps:   racingLaps.length,
    fastestLap:  fastest.toFixed(3),
    averageLap:  average.toFixed(3),
    consistency: stdDev.toFixed(3) // Lower = more consistent
  };
}

Track pit stop activity

Pit stop data tells you two things during testing: how well teams are practising their mechanics, and how frequently cars are being brought in for systems adjustments. A high number of unscheduled pit stops is often a quiet signal of reliability work happening behind closed doors.

Use the /fixture/{fixture_id}/pitstops endpoint to retrieve all stops for a session.

async function getPitStops(fixtureId) {
  const API_TOKEN = 'YOUR_TOKEN';

  const url = `https://api.sportmonks.com/v3/motorsport/fixture/${fixtureId}/pitstops`
            + `?api_token=${API_TOKEN}&include=driver,team`;

  const response = await fetch(url);
  const data     = await response.json();

  return data.data;
}

async function getLatestPitStop(fixtureId) {
  const API_TOKEN = 'YOUR_TOKEN';

  const url = `https://api.sportmonks.com/v3/motorsport/fixtures/${fixtureId}/pitstops/latest`
            + `?api_token=${API_TOKEN}&include=driver,team`;

  const response = await fetch(url);
  const data     = await response.json();

  console.log('Latest stop:', data.data);
  return data.data;
}

function comparePitStopsByTeam(pitStops) {
  const teamStats = {};

  pitStops.forEach(stop => {
    const team = stop.team?.name || 'Unknown';
    if (!teamStats[team]) {
      teamStats[team] = { stops: [], totalDuration: 0 };
    }
    teamStats[team].stops.push(stop.duration);
    teamStats[team].totalDuration += stop.duration;
  });

  return Object.entries(teamStats).map(([team, stats]) => ({
    team,
    totalStops:   stats.stops.length,
    avgDuration:  (stats.totalDuration / stats.stops.length).toFixed(2) + 's'
  })).sort((a, b) => parseFloat(a.avgDuration) - parseFloat(b.avgDuration));
}

Monitor tyre stints

Tyre stint data is one of the most underutilised data points in testing analysis. Because compound performance and degradation are among the biggest unknowns heading into 2026, stint data from testing gives early clues about how each compound performs across different car setups and team philosophies.

The /fixtures/{fixture_id}/stints endpoint returns all stints for a given session.

async function getTyreStints(fixtureId) {
  const API_TOKEN = 'YOUR_TOKEN';

  const url = `https://api.sportmonks.com/v3/motorsport/fixtures/${fixtureId}/stints`
            + `?api_token=${API_TOKEN}&include=driver,team`;

  const response = await fetch(url);
  const data     = await response.json();

  return data.data;
}

function buildDriverStrategyMap(stints) {
  const strategies = {};

  stints.forEach(stint => {
    const driver = stint.driver?.name || `Driver ${stint.driver_id}`;
    if (!strategies[driver]) {
      strategies[driver] = [];
    }
    strategies[driver].push({
      compound:      stint.tyre_compound,
      lapsCompleted: stint.laps_completed,
      startLap:      stint.lap_start,
      endLap:        stint.lap_end
    });
  });

  return strategies;
}

Check driver and team info

If you’re building a testing tracker that surfaces driver and team profiles, the /drivers and /teams endpoints give you the data you need.

// Get all drivers
async function getAllDrivers() {
  const API_TOKEN = 'YOUR_TOKEN';

  const url = `https://api.sportmonks.com/v3/motorsport/drivers`
            + `?api_token=${API_TOKEN}&include=team`;

  const response = await fetch(url);
  const data     = await response.json();

  return data.data;
}

// Search for a specific driver by name
async function findDriver(name) {
  const API_TOKEN = 'YOUR_TOKEN';

  const url = `https://api.sportmonks.com/v3/motorsport/drivers/search/${encodeURIComponent(name)}`
            + `?api_token=${API_TOKEN}&include=team`;

  const response = await fetch(url);
  const data     = await response.json();

  return data.data;
}

// Get all constructor teams, including their drivers
async function getAllTeams() {
  const API_TOKEN = 'YOUR_TOKEN';

  const url = `https://api.sportmonks.com/v3/motorsport/teams`
            + `?api_token=${API_TOKEN}&include=drivers`;

  const response = await fetch(url);
  const data     = await response.json();

  return data.data;
}

Building a testing dashboard: putting it together

If you want to build a complete F1 pre-season testing tracker, the class below brings together all of the above into a single interface. It handles fetching sessions, polling for live data, and pulling detailed per-driver stats on demand.

class F1TestingTracker {
  constructor(apiToken) {
    this.apiToken = apiToken;
    this.baseUrl  = 'https://api.sportmonks.com/v3/motorsport';
  }

  // 1. Get all sessions in the testing window
  async getTestingSessions(startDate = '2026-02-18', endDate = '2026-02-20') {
    const url = `${this.baseUrl}/fixtures/between/${startDate}/${endDate}`
              + `?api_token=${this.apiToken}&include=venue,stage,state`;

    const res  = await fetch(url);
    const data = await res.json();
    return data.data;
  }

  // 2. Get live data for any currently active session
  async getLiveSessions() {
    const url  = `${this.baseUrl}/livescores?api_token=${this.apiToken}&include=state,participants,venue`;
    const res  = await fetch(url);
    const data = await res.json();
    return data.data;
  }

  // 3. Get full stats for a completed or live session
  async getSessionStats(fixtureId) {
    const [lapsRes, pitstopsRes, stintsRes] = await Promise.all([
      fetch(`${this.baseUrl}/fixtures/${fixtureId}/laps?api_token=${this.apiToken}&include=driver,team`),
      fetch(`${this.baseUrl}/fixture/${fixtureId}/pitstops?api_token=${this.apiToken}&include=driver,team`),
      fetch(`${this.baseUrl}/fixtures/${fixtureId}/stints?api_token=${this.apiToken}&include=driver,team`)
    ]);

    const [laps, pitstops, stints] = await Promise.all([
      lapsRes.json(),
      pitstopsRes.json(),
      stintsRes.json()
    ]);

    return {
      laps:     laps.data,
      pitstops: pitstops.data,
      stints:   stints.data
    };
  }

  // 4. Build a per-driver summary for a session
  async getDriverSummary(fixtureId) {
    const { laps, stints, pitstops } = await this.getSessionStats(fixtureId);

    const drivers = {};

    laps.forEach(lap => {
      const name = lap.driver?.name || `ID:${lap.driver_id}`;
      if (!drivers[name]) drivers[name] = { laps: [], stints: [], pitstops: [] };
      drivers[name].laps.push(lap.time);
    });

    stints.forEach(stint => {
      const name = stint.driver?.name || `ID:${stint.driver_id}`;
      if (drivers[name]) {
        drivers[name].stints.push({ compound: stint.tyre_compound, laps: stint.laps_completed });
      }
    });

    pitstops.forEach(stop => {
      const name = stop.driver?.name || `ID:${stop.driver_id}`;
      if (drivers[name]) drivers[name].pitstops.push(stop.duration);
    });

    return Object.entries(drivers).map(([driver, stats]) => {
      const validLaps = stats.laps.filter(t => t > 0);
      const fastest   = validLaps.length ? Math.min(...validLaps).toFixed(3) : 'N/A';
      const avgLap    = validLaps.length
        ? (validLaps.reduce((a, b) => a + b, 0) / validLaps.length).toFixed(3)
        : 'N/A';

      return {
        driver,
        totalLaps:     validLaps.length,
        fastestLap:    fastest,
        averageLap:    avgLap,
        totalStints:   stats.stints.length,
        totalPitstops: stats.pitstops.length,
        compounds:     [...new Set(stats.stints.map(s => s.compound))]
      };
    });
  }
}

// Usage
const tracker = new F1TestingTracker('YOUR_TOKEN');

tracker.getTestingSessions().then(sessions => {
  console.log('Testing sessions found:', sessions.length);

  if (sessions.length > 0) {
    tracker.getDriverSummary(sessions[0].id).then(summary => {
      console.table(summary);
    });
  }
});

Sportmonks and F1

Turn every lap, stint, and pit stop into structured insight.

Build your own live testing dashboard with real-time sessions, lap-by-lap timing, tyre data, and driver analytics powered by the Sportmonks Motorsport API v3.

From pre-season testing to the season finale, get the data layer serious F1 applications rely on.

Start building with Sportmonks today.