# Tennis Scraper – Results, Odds, H2H & ATP/WTA Rankings (`smoldesk/tennis-scraper`) Actor

Scrape tennis results, fixtures and betting odds from TennisExplorer: set scores, opening and closing odds from 15 bookmakers, H2H, player stats and ATP/WTA rankings. ATP, WTA, Challenger, ITF. No login.

- **URL**: https://apify.com/smoldesk/tennis-scraper.md
- **Developed by:** [Smoldesk Studios](https://apify.com/smoldesk) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 matches

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Tennis Scraper – Results, Odds, H2H & ATP/WTA Rankings

Scrape **tennis results, upcoming matches and betting odds** for every ATP, WTA, Challenger, ITF and UTR match, from TennisExplorer. Each match comes with **set-by-set scores and tiebreaks**, **seeds**, **round and surface**, **closing odds with implied probabilities**, and whether the **favourite or the underdog won**. Turn on match details for **opening and closing odds from 10–15 bookmakers**, the **head-to-head record**, and both players' **ranking, age, height and playing hand**. Also scrapes **player profiles** (win/loss by year and surface) and **ATP/WTA rankings**. Results go back to the early 2000s (odds from about 2009). No login, no API key, no browser.

### What you can use it for

- **Betting models and backtests**: years of results with closing odds, opening odds and odds movement per bookmaker, in one table.
- **Daily results and fixtures feeds**: schedule the Actor with `yesterday` → `+2` and get every finished and upcoming match each morning.
- **Value and line-movement tracking**: compare opening vs closing odds, best vs average price, and the bookmaker margin per match.
- **Player and surface analysis**: win/loss per surface and season, H2H history, upsets by round or ranking gap.
- **Tennis apps, newsletters and AI agents**: clean JSON with a one-line `summary` per match.

### How to scrape tennis results and odds

1. Create a free Apify account and open this Actor.
2. Pick what to scrape:
   - **Start date / End date** for every match on those days (`2026-10-17`, `yesterday`, `-7`, `+2`).
   - **Match types** (ATP/WTA singles or doubles, mixed) and **Tournament levels** (tour, Challenger, ITF, UTR, team cups / club leagues / exhibitions) to narrow it down. Add words to **Tournament name contains** (`Wimbledon`) or **Player name contains** (`Sinner`).
   - Or paste **Tournament URLs** for a whole draw, **Player URLs** for a profile plus their season, or **Match URLs**.
   - Tick **Rankings** for ATP / WTA singles, doubles or race lists.
3. Turn on **Match details** if you need every bookmaker's odds, H2H and player bios. Add **Odds movement history** and **Over/Under, Asian Handicap and Correct Score odds** for the full betting picture.
4. Click **Start**. A day of matches takes a few seconds.
5. Download the results as JSON, CSV or Excel, or read them through the Apify API.
6. Use **Schedule** to run it every day. With start date `yesterday` and end date `+2` you always get the latest results plus the next fixtures.

**Tips**

- For large backfills, leave match details off first (one page per day, ~400 matches); add details only for the matches you model.
- Use **Match status: Played** for results only, or **Upcoming** for fixtures with odds.
- **Max matches** and the run's maximum cost both stop the run cleanly. You only pay for saved results.

### Output: match

```json
{
  "type": "match",
  "matchId": "3350891",
  "url": "https://www.tennisexplorer.com/match-detail/?id=3350891",
  "date": "2026-10-17",
  "startTime": "13:10",
  "startTimeUtc": "2026-10-17T11:10:00Z",
  "status": "finished",
  "tour": "ATP",
  "matchType": "singles",
  "level": "tour",
  "tournament": "Shanghai",
  "tournamentUrl": "https://www.tennisexplorer.com/shanghai/2026/atp-men/",
  "tournamentCountry": "CN",
  "round": "semifinal",
  "surface": "hard",
  "player1": "Jodar R.",
  "player1Url": "https://www.tennisexplorer.com/player/jodar/",
  "player1Seed": "12",
  "player2": "Medvedev D.",
  "player2Url": "https://www.tennisexplorer.com/player/medvedev-e0d2d/",
  "player2Seed": "5",
  "winner": "Jodar R.",
  "winnerSide": "player1",
  "score": "6-3 6-4",
  "setsPlayer1": 2,
  "setsPlayer2": 0,
  "sets": [
    { "player1": 6, "player2": 3, "tiebreak": null },
    { "player1": 6, "player2": 4, "tiebreak": null }
  ],
  "oddsPlayer1": 2.57,
  "oddsPlayer2": 1.51,
  "impliedProbPlayer1": 0.3701,
  "impliedProbPlayer2": 0.6299,
  "bookmakerMargin": 0.0514,
  "favorite": "player2",
  "upset": true,
  "h2hPlayer1Wins": null,
  "h2hPlayer2Wins": null,
  "source": "daily",
  "summary": "Jodar R. (12) beat Medvedev D. (5) 6-3 6-4 — Shanghai semifinal on hard, 2026-10-17 13:10 CET/CEST. Closing odds 2.57 vs 1.51 (upset).",
  "scrapedAt": "2026-10-18T10:40:00Z"
}
```

- `level`: `tour` (ATP/WTA tour, Grand Slams, Finals), `challenger`, `itf`, `utr` or `team-exhibition` (Davis Cup, United Cup, Laver Cup, club leagues such as the Bundesliga, exhibitions).
- `status`: `finished`, `retired`, `walkover`, `scheduled` (no result yet) or `noResult` (past match with no score, e.g. cancelled).
- `tiebreak`: points of the player who lost the tiebreak (`7-6(4)`). Doubles match tiebreaks show as the third set (`10-7`).
- `implied…` are the closing odds with the bookmaker margin removed. `upset` = the player with the higher odds won.
- For finished matches the winner is always `player1`. For upcoming matches the order is the site's home/away order.

#### Extra fields with match details

```json
{
  "player1FullName": "Jodar Rafael",
  "player1Details": {
    "photoUrl": "https://www.tennisexplorer.com/res/img/player/fXkcYoya-bJuw1oYE.jpeg",
    "singlesRank": 13,
    "birthDate": "2006-09-17",
    "heightCm": null,
    "weightKg": null,
    "plays": "right",
    "turnedPro": null
  },
  "player2FullName": "Medvedev Daniil",
  "h2h": {
    "player1Wins": 1,
    "player2Wins": 0,
    "matches": [
      { "year": 2026, "tournament": "Shanghai", "winner": "Jodar", "loser": "Medvedev", "score": "6-3 6-4", "surface": "Hard", "round": "semifinal", "matchId": "3350891" }
    ]
  },
  "oddsSummary": {
    "bookmakers": 15,
    "player1Average": 2.565,
    "player2Average": 1.507,
    "player1Best": 2.63,
    "player2Best": 1.56,
    "player1OpeningAverage": 2.371,
    "player2OpeningAverage": 1.532
  },
  "bookmakerOdds": [
    { "bookmaker": "10Bet", "player1": 2.55, "player2": 1.48, "player1Opening": 2.5, "player2Opening": 1.5, "openedAt": "2026-10-16T13:30:00Z" },
    { "bookmaker": "1xBet", "player1": 2.61, "player2": 1.52, "player1Opening": 2.58, "player2Opening": 1.53, "openedAt": "2026-10-16T12:42:00Z" }
  ]
}
```

- **Odds movement history** adds `player1History` / `player2History` to each bookmaker: every change with its UTC time.
- **Other markets** adds `markets.overUnder` (total sets / games lines), `markets.handicap` (set and game handicaps) and `markets.correctScore`, one row per bookmaker and line.
- Doubles: `player1Team` / `player2Team` list both players with their bios.

### Output: player

```json
{
  "type": "player",
  "name": "Jodar Rafael",
  "url": "https://www.tennisexplorer.com/player/jodar/",
  "country": "Spain",
  "birthDate": "2006-09-17",
  "age": 20,
  "plays": "right",
  "singlesRank": 13,
  "singlesRankHighest": 11,
  "doublesRank": 353,
  "doublesRankHighest": 344,
  "photoUrl": "https://www.tennisexplorer.com/res/img/player/fXkcYoya-bJuw1oYE.jpeg",
  "singlesRecord": [
    { "year": "career", "totalWins": 105, "totalLosses": 39, "clayWins": 29, "clayLosses": 12, "hardWins": 55, "hardLosses": 22, "indoorsWins": 18, "indoorsLosses": 4, "grassWins": 2, "grassLosses": 1 },
    { "year": 2026, "totalWins": 56, "totalLosses": 17, "clayWins": 19, "clayLosses": 4, "hardWins": 31, "hardLosses": 11, "indoorsWins": 3, "indoorsLosses": 1, "grassWins": 2, "grassLosses": 1 }
  ]
}
```

The player's singles matches for the chosen seasons are saved as match records (`source: "player"`) with round, surface, score and odds.

### Output: ranking

```json
{
  "type": "ranking",
  "ranking": "ATP singles",
  "rankingDate": "2026-10-05",
  "rank": 1,
  "movement": 0,
  "player": "Sinner Jannik",
  "playerUrl": "https://www.tennisexplorer.com/player/sinner-8b8e8/",
  "country": "Italy",
  "countryCode": "IT",
  "points": 11000
}
```

### Input examples

Yesterday's ATP and WTA singles results with every bookmaker's odds:

```json
{
  "startDate": "yesterday",
  "matchTypes": ["atp-single", "wta-single"],
  "matchStatus": "finished",
  "includeMatchDetails": true
}
```

A full season of tour-level and Challenger results for backtesting:

```json
{
  "startDate": "2025-01-01",
  "endDate": "2025-12-31",
  "matchTypes": ["atp-single"],
  "levels": ["tour", "challenger"]
}
```

Whole draws, a player's seasons and the top 200:

```json
{
  "tournamentUrls": ["https://www.tennisexplorer.com/wimbledon/2025/atp-men/"],
  "playerUrls": ["https://www.tennisexplorer.com/player/sinner-8b8e8/"],
  "playerSeasons": ["2025", "2026"],
  "rankings": ["atp-singles", "wta-singles"],
  "rankingTopN": 200
}
```

### Pricing

Pay per result. No monthly fee, and Apify's free plan credit covers your first runs.

| What | Price | Per 1,000 |
|---|---|---|
| Match (score, round, surface, closing odds, implied probability) | $0.002 | **$2.00** |
| Match details (all bookmakers' odds, H2H, player bios, optional odds history and markets) | +$0.003 | +$3.00 |
| Player profile | $0.003 | $3.00 |
| Ranking row | $0.0005 | $0.50 |
| Run start | $0.00005 | – |

Example: one full day of every match (~400) costs about **$0.80**. A whole ATP singles season of tour + Challenger results, qualifying included (~14,000 matches), costs about **$28**, or about $70 with every bookmaker's odds and H2H. If a match page can't be loaded, its details are not charged.

### Use with AI (LangChain / LlamaIndex / CrewAI)

Every match has a `summary` line, so the dataset drops straight into an LLM or RAG pipeline. With LangChain (`pip install langchain-apify`):

```python
from langchain_apify import ApifyWrapper
from langchain_core.documents import Document

apify = ApifyWrapper()  # reads APIFY_API_TOKEN
loader = apify.call_actor(
    actor_id="smoldesk/tennis-scraper",
    run_input={"startDate": "-7", "endDate": "yesterday", "matchTypes": ["atp-single"], "levels": ["tour"]},
    dataset_mapping_function=lambda v: Document(
        page_content=v.get("summary") or "",
        metadata={k: v.get(k) for k in ("date", "tournament", "round", "surface", "winner", "score", "url")},
    ),
)
docs = loader.load()
```

Already have a run? Use `ApifyDatasetLoader(dataset_id="<run's dataset ID>", dataset_mapping_function=...)`. **LlamaIndex**: `ApifyActor` from `llama-index-readers-apify`. **CrewAI / Claude / MCP clients**: add the Actor as a tool through the Apify MCP server: `https://mcp.apify.com?actors=smoldesk/tennis-scraper`.

### Limitations

- **Not a live-score feed.** Scores appear once a match is finished. A match in progress shows as `scheduled` until then.
- **Retirements are inferred**: the site has no retirement label, so a match whose last set was not finished is marked `retired`. A player who retires right after completing a set in a best-of-five match can show as `finished`.
- **H2H is the record at the time you scrape**, not at the time of the match.
- **Round and surface** come from the tournament draw page. Team cups, club leagues, round-robin events and some ITF "Futures" groups have no round on the site, so `round` is empty there. In a full 2025 season of ATP tour + Challenger singles, 2% of matches had no round.
- Times are the site's Central European time (`startTime`) and converted to UTC (`startTimeUtc`). Old matches often have no start time.
- Odds are the prices the site lists (mostly European bookmakers). Coverage is thin before about 2009 and for low-level ITF matches.

### FAQ

**Is there a free tennis odds API?** Not really: the official ATP/WTA data and most odds APIs are paid. This Actor reads the public TennisExplorer pages, so you pay only per result.

**Can I get historical tennis results with odds?** Yes. Set a date range (results go back to the early 2000s, odds to about 2009) or paste tournament URLs from past years.

**Does it include Challenger and ITF matches?** Yes: ATP, WTA, Challenger, ITF/Futures and UTR Pro Tennis Series, singles and doubles, plus team cups, club leagues and exhibitions. Filter with **Tournament levels** (a 2025 ATP singles run had ~3,900 tour, ~10,400 Challenger and ~2,200 team/exhibition matches).

**How do I get only one tournament, like Wimbledon?** Paste its tournament URL, or set dates plus **Tournament name contains: Wimbledon**.

**Do I need a login, cookies or proxies?** No. It works from Apify's servers without a proxy. Residential proxies are never needed.

**Is it legal to scrape tennis results?** Results and odds are public facts shown without a login. Check the site's terms and your local rules for your use case, especially for betting. This Actor is not affiliated with TennisExplorer, the ATP or the WTA.

### Feedback

Found a bug or missing a field? Open an issue in the **Issues** tab. If the Actor saved you time, a short review on this page helps other people find it.

### More Actors from Smoldesk Studios

- [Google Ads Transparency Scraper](https://apify.com/smoldesk/google-ads-transparency-scraper): every ad a competitor runs on Google Search, YouTube and Shopping — creatives, landing pages, countries, EU impressions and new-ad alerts
- [Weibo Scraper](https://apify.com/smoldesk/weibo-scraper): keyword and hashtag search, posts, comments, profiles and the hot-search board from China's biggest microblog, no login
- [Bilibili Scraper](https://apify.com/smoldesk/bilibili-scraper): videos, stats, danmaku, comments and creators from China's video site, no login
- [Google Hotels Scraper](https://apify.com/smoldesk/google-hotels-scraper): hotel prices for your dates in any currency, ratings, review aspects and booking-site prices, worldwide
- [Google Trends Scraper](https://apify.com/smoldesk/google-trends-scraper): interest over time, by region and city, related queries and Trending now — no API key
- [Telegram Channel Scraper](https://apify.com/smoldesk/telegram-channel-scraper): public channel posts, views, reactions and subscribers
- [Substack Scraper](https://apify.com/smoldesk/substack-scraper): newsletters, subscriber counts and posts
- [Shopify Store Analyzer](https://apify.com/smoldesk/shopify-store-analyzer): apps, contacts and products of any Shopify store
- [Career Site Jobs Scraper](https://apify.com/smoldesk/career-site-jobs-scraper): live jobs from 13,000+ company career sites (Greenhouse, Lever, Workday, Ashby) with salary and seniority
- [SEEK, JobStreet & JobsDB Scraper](https://apify.com/smoldesk/seek-jobs-scraper): jobs and salaries across Australia and Southeast Asia

# Actor input Schema

## `startDate` (type: `string`):

First day to scrape: YYYY-MM-DD, or relative: today, yesterday, tomorrow, -7 (7 days ago), +2 (in 2 days). Every listed match that day is scraped: results and upcoming fixtures, ATP, WTA, Challenger, ITF and UTR. Dates go back to the early 2000s (odds from about 2010).

## `endDate` (type: `string`):

Last day to scrape (same formats). Leave empty to scrape only the start date. Use 'today' with start date '-7' for a rolling last-week window in scheduled runs.

## `matchTypes` (type: `array`):

Which draws to keep. Empty = all. Applies to the date range only — tournament, player and match URLs are always scraped in full.

## `levels` (type: `array`):

Which tournament levels to keep. Empty = all. 'tour' = ATP/WTA tour events and Grand Slams; 'team-exhibition' = Davis Cup, United Cup, Laver Cup, club leagues (Bundesliga…) and exhibitions. Applies to the date range only — tournament, player and match URLs are always scraped in full.

## `tournamentNames` (type: `array`):

Keep only matches whose tournament name contains one of these words (case-insensitive), e.g. 'Shanghai', 'Wimbledon', 'US Open'. Applies to the date range only — tournament, player and match URLs are always scraped in full.

## `playerNames` (type: `array`):

Keep only matches with a player whose name contains one of these (case-insensitive). Names are listed as 'Surname I.', e.g. 'Sinner', 'Alcaraz'. Applies to the date range only — tournament, player and match URLs are always scraped in full.

## `matchStatus` (type: `string`):

All matches, only played ones (finished, retired, walkover) or only upcoming ones (no result yet). Applies to the date range only — tournament, player and match URLs are always scraped in full.

## `maxMatches` (type: `integer`):

Stop after this many matches in total (all sources). 0 or empty = no limit.

## `includeRoundAndSurface` (type: `boolean`):

Fills each match's round (1. round … final, qualifying) and court surface from the tournament draw page. One extra page per tournament, no extra charge. Not needed when match details are on.

## `includeMatchDetails` (type: `boolean`):

Opens each match page for: closing and opening odds from each bookmaker (usually 10-15), average/best odds, head-to-head record with past meetings, round, surface, and both players' ranking, birth date, height, weight and playing hand. Charged as an extra 'match details' event.

## `includeOddsHistory` (type: `boolean`):

Adds every odds change per bookmaker with its timestamp (UTC). Turns on match details.

## `includeAllMarkets` (type: `boolean`):

Adds the other betting markets: total sets/games over-under, set/game handicaps and correct-score odds per bookmaker. Turns on match details.

## `tournamentUrls` (type: `array`):

TennisExplorer tournament pages, e.g. https://www.tennisexplorer.com/wimbledon/2025/atp-men/ (add ?type=double for doubles or ?phase=qualification for qualifying). Every match of the draw is scraped with its round.

## `playerUrls` (type: `array`):

TennisExplorer player pages (https://www.tennisexplorer.com/player/sinner-8b8e8/) or just the slug (sinner-8b8e8). Gives a player profile (rankings, age, height, plays, win/loss by year and surface) plus their singles matches for the chosen seasons.

## `playerSeasons` (type: `array`):

Years of matches to fetch for each player, e.g. 2025, 2026. Empty = current season.

## `includePlayerMatches` (type: `boolean`):

Off = only the player profile records.

## `matchUrls` (type: `array`):

Single matches: TennisExplorer match-detail URLs or IDs (https://www.tennisexplorer.com/match-detail/?id=3350891). Always returned with full details.

## `rankings` (type: `array`):

ATP / WTA ranking lists to scrape (rank, movement, points, country).

## `rankingTopN` (type: `integer`):

How many players per ranking list (from #1).

## `rankingDate` (type: `string`):

Optional past ranking week (YYYY-MM-DD, a Monday the ranking was published). Empty = latest.

## `proxyConfiguration` (type: `object`):

Optional. TennisExplorer works from Apify servers without a proxy. Residential proxies are not needed.

## Actor input object example

```json
{
  "startDate": "yesterday",
  "endDate": "today",
  "matchTypes": [
    "atp-single",
    "wta-single"
  ],
  "matchStatus": "all",
  "maxMatches": 100,
  "includeRoundAndSurface": true,
  "includeMatchDetails": false,
  "includeOddsHistory": false,
  "includeAllMarkets": false,
  "tournamentUrls": [],
  "includePlayerMatches": true,
  "rankingTopN": 100
}
```

# Actor output Schema

## `matches` (type: `string`):

Results and fixtures (type = match).

## `odds` (type: `string`):

Match odds and implied probabilities (type = match).

## `players` (type: `string`):

Player profiles (type = player).

## `rankings` (type: `string`):

ATP / WTA ranking rows (type = ranking).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startDate": "yesterday",
    "endDate": "today",
    "matchTypes": [
        "atp-single",
        "wta-single"
    ],
    "maxMatches": 100,
    "tournamentUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("smoldesk/tennis-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startDate": "yesterday",
    "endDate": "today",
    "matchTypes": [
        "atp-single",
        "wta-single",
    ],
    "maxMatches": 100,
    "tournamentUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("smoldesk/tennis-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startDate": "yesterday",
  "endDate": "today",
  "matchTypes": [
    "atp-single",
    "wta-single"
  ],
  "maxMatches": 100,
  "tournamentUrls": []
}' |
apify call smoldesk/tennis-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,smoldesk/tennis-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/GhhjqmKoTMZlO0sp4/builds/CKMcWPiDVKTI5YNQ3/openapi.json