# Polymarket and Kalshi Arbitrage Verifier (`redfoxxie/polymarket-kalshi-arbitrage-verifier`) Actor

Verify Polymarket and Kalshi contract matches with execution-sized order-book VWAPs, current fee math, one-tick stress, semantic conflict flags, and explicit non-atomic execution warnings. Built for agents, analysts, and trading dashboards that need evidence beyond headline price gaps.

- **URL**: https://apify.com/redfoxxie/polymarket-kalshi-arbitrage-verifier.md
- **Developed by:** [João Ferreira](https://apify.com/redfoxxie) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$30.00 / 1,000 verified cross-market pairs

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

> This is an independent data product and is **not affiliated with, sponsored by, or endorsed by Polymarket or Kalshi**. It does not place orders or provide financial advice.

The Actor runs with **limited-permission** access: default run storage and public
network requests only. Its pay-per-event, non-Standby architecture meets the
technical prerequisites for agentic-payment discovery when Apify marks the
published Actor as eligible.

### Polymarket and Kalshi Arbitrage Verifier

Find contracts that appear to describe the same event on Polymarket and Kalshi,
then replace headline-price arithmetic with execution-sized evidence. The Actor
walks both live order books for an equal contract quantity, applies each
platform's fee model, calculates both opposite-side routes, and repeats the
calculation after moving both entries one tick against the trader.

The result is deliberately called a **candidate verification**, not guaranteed
arbitrage. Two similarly titled markets may use different observation times,
sources, threshold boundaries, cancellation clauses, or settlement rules.
Cross-platform legs are also non-atomic. Every output therefore includes the
relevant rule excerpts, hard automated conflicts, and a mandatory manual-review
flag next to conditional PnL.

### What makes the output useful

- Polymarket YES and NO prices are walked through CLOB ask levels at the exact
  requested size rather than copied from a headline probability.
- Kalshi's bid-only book is converted correctly: a NO bid at `x` supplies a YES
  ask at `1-x`, with the same displayed quantity.
- Polymarket's current Gamma fee schedule is used per market, with a conservative
  fallback clearly labeled when metadata is incomplete.
- Kalshi's current general taker formula is rounded up to the next cent. The
  coefficient is an explicit input because product-specific fee exceptions can
  change and are not proven by the public order-book response.
- Numbers, negation, threshold direction, and close-time differences are treated
  as semantic conflicts rather than hidden inside one fuzzy-match score.
- Both `buy Polymarket YES + Kalshi NO` and the reverse route are reported under
  base and one-tick adverse execution.

### Example input

```json
{
  "explicitPairs": [
    {
      "polymarketMarketId": "1234567",
      "kalshiTicker": "KXEXAMPLE-26DEC31"
    }
  ],
  "discoveryEnabled": true,
  "queries": ["Federal Reserve", "Bitcoin"],
  "contracts": 5,
  "maxCandidates": 25,
  "minSemanticScore": 0.68,
  "maxCloseDifferenceHours": 48,
  "kalshiTakerFeeRate": 0.07,
  "positiveAfterStressOnly": false
}
````

Leave `queries` empty to search the fetched active universe. Use a topic when a
scheduled workflow needs lower latency and a smaller output. A higher semantic
score reduces candidates but cannot prove rule equivalence. Review both rule
excerpts on the exchange before acting on any record.

For deterministic verification, provide `explicitPairs` and set
`discoveryEnabled` to `false`. Explicit pairs are always returned when both
public market records exist, including when the verifier finds hard conflicts.
That makes the Actor useful as a second opinion for candidates produced by
other scanners rather than forcing users to trust this Actor's discovery model.

### Search-ready examples

The publication bundle defines runnable tasks for broad candidate discovery,
Bitcoin-focused comparison, and one-tick-stressed filtering. The exact inputs
are versioned in `public_tasks.json`. They are discovery aids, not assertions
that matching markets or executable arbitrage exist at run time.

### Output contract

Each dataset row contains platform identities, contract quantity, semantic
checks, fee provenance, both route calculations, one-tick stress, depth status,
and an execution warning. Profit fields are named
`net_pnl_if_rules_equivalent_usd` so downstream systems cannot reasonably
mistake a conditional calculation for a guaranteed payout.

Every run also emits one free `scan_summary` row. It reports how many explicit
pairs were requested and resolved, how many markets were fetched per platform,
how many discovery matches were found, and how many pair records survived. A
zero-result scan is therefore distinguishable from an upstream or Actor error.

The Actor uses public market-data endpoints only. It accepts no exchange API
keys, wallet credentials, private keys, or order instructions. It never places,
cancels, or simulates a user order.

### Pricing

Explicit pair audits emit the `verified_cross_market_pair` event at **$0.03**
for every successfully returned pair. Automatically discovered candidates use
a three-record free preview, then emit the same event at **$0.03** each. There
is **no start fee**. The launch model is **Pay per event + usage**, so Apify
platform usage is charged separately to the runner instead of quietly consuming
the creator's operating budget. Missing or failed explicit pairs emit no paid
event.

### Data limitations

REST books can move between platform requests. A positive stressed route is not
an atomic fill promise. Kalshi may apply a product-specific fee schedule, and
the public data used here does not certify that exception status. Polymarket
resolution descriptions and Kalshi rules can encode different boundary or
timing semantics even when titles match. This Actor is a fast, structured
pre-trade audit that removes obvious false positives; final contract review and
execution responsibility remain with the user.

Official mechanics referenced by the implementation:
[Polymarket CLOB](https://docs.polymarket.com/developers/CLOB/introduction),
[Polymarket negative risk](https://docs.polymarket.com/advanced/neg-risk),
[Kalshi public market data](https://docs.kalshi.com/getting_started/quick_start_market_data),
and [Kalshi order-book interpretation](https://docs.kalshi.com/getting_started/orderbook_responses).

# Actor input Schema

## `explicitPairs` (type: `array`):

Pairs to verify directly. Each object needs polymarketMarketId and kalshiTicker. Explicit pairs are evaluated even when semantic conflicts are found.

## `discoveryEnabled` (type: `boolean`):

Search the active public universes in addition to verifying explicit pairs. Disable for a faster deterministic audit run.

## `queries` (type: `array`):

Optional topic phrases. Every phrase token must occur in the Polymarket title. Leave empty to scan the fetched universe.

## `contracts` (type: `number`):

Equal position size used to walk each platform's executable order book. The Polymarket five-share minimum is enforced.

## `maxCandidates` (type: `integer`):

Maximum matched pairs to verify. The first three dataset records per run are free.

## `universeLimitPerPlatform` (type: `integer`):

Maximum active markets fetched independently from Polymarket and Kalshi before semantic candidate matching.

## `minSemanticScore` (type: `number`):

Minimum automated title/date/numeric compatibility score. This score never proves resolution-rule equivalence.

## `maxCloseDifferenceHours` (type: `number`):

Maximum hours between platform close or expected-expiration timestamps before the pair receives a hard conflict.

## `kalshiTakerFeeRate` (type: `number`):

Fee coefficient used with ceil(rate x contracts x price x (1-price)). Defaults to the current general schedule; market exceptions must be reviewed.

## `positiveAfterStressOnly` (type: `boolean`):

Return only pairs whose best route remains positive after moving both entry prices one tick adversely, assuming equivalent rules.

## `includeSummary` (type: `boolean`):

Emit an always-free summary with universe, lookup, candidate and returned-record counts, including when no pair qualifies.

## Actor input object example

```json
{
  "explicitPairs": [
    {
      "polymarketMarketId": "1234567",
      "kalshiTicker": "KXEXAMPLE-26DEC31"
    }
  ],
  "discoveryEnabled": true,
  "queries": [
    "Bitcoin",
    "Federal Reserve"
  ],
  "contracts": 5,
  "maxCandidates": 25,
  "universeLimitPerPlatform": 1000,
  "minSemanticScore": 0.68,
  "maxCloseDifferenceHours": 48,
  "kalshiTakerFeeRate": 0.07,
  "positiveAfterStressOnly": false,
  "includeSummary": true
}
```

# Actor output Schema

## `verifiedPairs` (type: `string`):

Semantic conflicts, executable VWAPs, fees, one-tick stress and conditional route economics.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("redfoxxie/polymarket-kalshi-arbitrage-verifier").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("redfoxxie/polymarket-kalshi-arbitrage-verifier").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call redfoxxie/polymarket-kalshi-arbitrage-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=redfoxxie/polymarket-kalshi-arbitrage-verifier",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Polymarket and Kalshi Arbitrage Verifier",
        "description": "Verify Polymarket and Kalshi contract matches with execution-sized order-book VWAPs, current fee math, one-tick stress, semantic conflict flags, and explicit non-atomic execution warnings. Built for agents, analysts, and trading dashboards that need evidence beyond headline price gaps.",
        "version": "0.1",
        "x-build-id": "ekpzyq50yDru7LqmP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/redfoxxie~polymarket-kalshi-arbitrage-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-redfoxxie-polymarket-kalshi-arbitrage-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/redfoxxie~polymarket-kalshi-arbitrage-verifier/runs": {
            "post": {
                "operationId": "runs-sync-redfoxxie-polymarket-kalshi-arbitrage-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/redfoxxie~polymarket-kalshi-arbitrage-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-redfoxxie-polymarket-kalshi-arbitrage-verifier",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "explicitPairs": {
                        "title": "Explicit contract pairs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Pairs to verify directly. Each object needs polymarketMarketId and kalshiTicker. Explicit pairs are evaluated even when semantic conflicts are found.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "polymarketMarketId": {
                                    "title": "Polymarket market ID",
                                    "type": "string",
                                    "description": "Gamma market ID for the Polymarket contract to compare.",
                                    "editor": "textfield",
                                    "maxLength": 100
                                },
                                "kalshiTicker": {
                                    "title": "Kalshi market ticker",
                                    "type": "string",
                                    "description": "Exact Kalshi market ticker for the comparison contract.",
                                    "editor": "textfield",
                                    "maxLength": 128
                                }
                            },
                            "required": [
                                "polymarketMarketId",
                                "kalshiTicker"
                            ],
                            "additionalProperties": false
                        },
                        "default": []
                    },
                    "discoveryEnabled": {
                        "title": "Discover additional pairs",
                        "type": "boolean",
                        "description": "Search the active public universes in addition to verifying explicit pairs. Disable for a faster deterministic audit run.",
                        "default": true
                    },
                    "queries": {
                        "title": "Topic filters",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Optional topic phrases. Every phrase token must occur in the Polymarket title. Leave empty to scan the fetched universe.",
                        "items": {
                            "type": "string",
                            "maxLength": 100
                        },
                        "default": []
                    },
                    "contracts": {
                        "title": "Contracts per leg",
                        "minimum": 5,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Equal position size used to walk each platform's executable order book. The Polymarket five-share minimum is enforced.",
                        "default": 5
                    },
                    "maxCandidates": {
                        "title": "Maximum candidate pairs",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum matched pairs to verify. The first three dataset records per run are free.",
                        "default": 25
                    },
                    "universeLimitPerPlatform": {
                        "title": "Markets fetched per platform",
                        "minimum": 100,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum active markets fetched independently from Polymarket and Kalshi before semantic candidate matching.",
                        "default": 1000
                    },
                    "minSemanticScore": {
                        "title": "Minimum semantic candidate score",
                        "minimum": 0,
                        "maximum": 1,
                        "type": "number",
                        "description": "Minimum automated title/date/numeric compatibility score. This score never proves resolution-rule equivalence.",
                        "default": 0.68
                    },
                    "maxCloseDifferenceHours": {
                        "title": "Maximum close-time difference",
                        "minimum": 0,
                        "maximum": 720,
                        "type": "number",
                        "description": "Maximum hours between platform close or expected-expiration timestamps before the pair receives a hard conflict.",
                        "default": 48
                    },
                    "kalshiTakerFeeRate": {
                        "title": "Kalshi taker fee coefficient",
                        "minimum": 0,
                        "maximum": 0.25,
                        "type": "number",
                        "description": "Fee coefficient used with ceil(rate x contracts x price x (1-price)). Defaults to the current general schedule; market exceptions must be reviewed.",
                        "default": 0.07
                    },
                    "positiveAfterStressOnly": {
                        "title": "Only positive one-tick candidates",
                        "type": "boolean",
                        "description": "Return only pairs whose best route remains positive after moving both entry prices one tick adversely, assuming equivalent rules.",
                        "default": false
                    },
                    "includeSummary": {
                        "title": "Include free run summary",
                        "type": "boolean",
                        "description": "Emit an always-free summary with universe, lookup, candidate and returned-record counts, including when no pair qualifies.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```