{
  "openapi": "3.0.1",
  "info": {
    "title": "Google Maps Scraper: Rating Trends, Leads, Reviews",
    "description": "Google Maps scraper with rating trends: business name, phone number, website, address, hours, reviews and the rating of the last 3, 6 and 12 months. A whole city past the 120-result limit, or places by URL or place ID. Free no-website filter. Google Places API alternative, no API key. No emails.",
    "version": "0.1",
    "x-build-id": "2REQwLWHkfQ69txQd"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/nokia2k~google-maps-scraper-rating-trends/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-nokia2k-google-maps-scraper-rating-trends",
        "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/nokia2k~google-maps-scraper-rating-trends/runs": {
      "post": {
        "operationId": "runs-sync-nokia2k-google-maps-scraper-rating-trends",
        "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/nokia2k~google-maps-scraper-rating-trends/run-sync": {
      "post": {
        "operationId": "run-sync-nokia2k-google-maps-scraper-rating-trends",
        "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": {
          "searchStringsArray": {
            "title": "Search terms",
            "type": "array",
            "description": "Enter what you would type into the Google Maps search bar, for example <b>dentist</b>, <b>coffee shop</b> or <b>plumber</b>. One term per line. Write the kind of business only and put the place in <b>Area</b>: a term such as <b>dentist in Austin</b> without an Area returns at most 120 places. Use the words a local customer would use. A place found by several terms is delivered, and charged, once. An area alone is not enough: add a term.",
            "items": {
              "type": "string"
            }
          },
          "locationQuery": {
            "title": "Area",
            "type": "string",
            "description": "Enter a city, district, county or region, such as <b>Santa Fe, New Mexico</b> or <b>Toledo, Spain</b>. Add the region or country when the name is common. You get the places inside its border, not only the first 120 Google Maps shows. A postal code with its town or country (78701, USA) delivers only places with that code. Without an area, a term is searched once: at most 120 places. Area not found: the run stops, no places are charged."
          },
          "locations": {
            "title": "More areas",
            "type": "array",
            "description": "Add further areas here, one per line, to cover several cities or regions in one run. A postal code with its town or country (78702, Austin, Texas) works here as in <b>Area</b>. A place that lies in two of them is delivered once. An area that is not found is skipped and named in the coverage record; the run stops only when none of your areas is found.",
            "items": {
              "type": "string"
            }
          },
          "maxCrawledPlacesPerSearch": {
            "title": "Places per search term",
            "minimum": 1,
            "type": "integer",
            "description": "Enter how many places to deliver for each search term in each area, counted after the filters. A search link is cut at this number too; place IDs and place links are not. You get the top places in Google's order. <b>Leave empty to get every place found in the area</b>, which can be thousands in one city. Start small (50) to see the data. Through the API there is no default limit: set this field, or a maximum cost for the run, in every call."
          },
          "language": {
            "title": "Language of the results",
            "enum": [
              "en",
              "af",
              "sq",
              "am",
              "ar",
              "hy",
              "az",
              "eu",
              "bn",
              "bs",
              "bg",
              "my",
              "ca",
              "zh-CN",
              "zh-TW",
              "hr",
              "cs",
              "da",
              "nl",
              "et",
              "fil",
              "fi",
              "fr",
              "gl",
              "ka",
              "de",
              "el",
              "gu",
              "iw",
              "hi",
              "hu",
              "is",
              "id",
              "it",
              "ja",
              "kn",
              "kk",
              "km",
              "ko",
              "ky",
              "lo",
              "lv",
              "lt",
              "mk",
              "ms",
              "ml",
              "mr",
              "mn",
              "ne",
              "no",
              "fa",
              "pl",
              "pt-BR",
              "pt-PT",
              "pa",
              "ro",
              "ru",
              "sr",
              "si",
              "sk",
              "sl",
              "es",
              "es-419",
              "sw",
              "sv",
              "ta",
              "te",
              "th",
              "tr",
              "uk",
              "ur",
              "uz",
              "vi",
              "zu"
            ],
            "type": "string",
            "description": "Choose the language for category names, opening hours and attribute labels. Review texts stay in the language they were written in.",
            "default": "en"
          },
          "coverage": {
            "title": "Coverage",
            "enum": [
              "standard",
              "deep"
            ],
            "type": "string",
            "description": "Choose how far to zoom in. <code>standard</code> keeps zooming while a closer look adds at least 3 new places. <code>deep</code> keeps zooming until a closer look adds nothing. In a test, deep returned about a quarter more places and took nearly twice as long.",
            "default": "standard"
          },
          "startUrls": {
            "title": "Google Maps links",
            "type": "array",
            "description": "Paste place links from the address bar of Google Maps, or a search link such as <code>https://www.google.com/maps/search/dentist/@30.2672,-97.7431,14z</code>, which returns one map view (up to 120 places). A short share link (maps.app.goo.gl) cannot be read: open it in your browser and paste the long one. A text file, one link per line, works too. In JSON: <code>[{\"url\": \"...\"}]</code>, or <code>[{\"requestsFromUrl\": \"...\"}]</code> for a file.",
            "items": {
              "type": "object",
              "properties": {
                "url": {
                  "type": "string",
                  "title": "URL",
                  "description": "A Google Maps place or search link."
                }
              }
            }
          },
          "placeIds": {
            "title": "Place IDs",
            "type": "array",
            "description": "Enter Google place IDs such as <code>ChIJm0hdIQ1QGIcRpDnU4qK8Q4M</code>, one per line, from the <code>placeId</code> column of an earlier run. Also read: an ID with <code>place_id:</code> in front, several IDs in one line, a Google Maps link. A CID number or a feature ID (the <code>cid</code> and <code>fid</code> columns) is skipped with a note. Every place ID is read, whatever Places per search term says. Same price as any other place.",
            "items": {
              "type": "string"
            }
          },
          "placeIdsFromDatasets": {
            "title": "Place IDs from earlier runs",
            "type": "array",
            "description": "Enter the dataset ID or the run ID of an earlier run of this Actor, one per line (a link to the run or its table works too). Every place in those tables is asked for again by its place ID, without searching the map: turn on <b>Recent reputation</b> or <b>Emails and social profiles</b> to add fresh data to places you already have, or run it as it is to see which places closed. Up to 60,000 place IDs; places that are in several tables are asked for once.",
            "items": {
              "type": "string"
            }
          },
          "skipPlaceIdsFromDatasets": {
            "title": "Places to skip",
            "type": "array",
            "description": "Enter the dataset ID or the run ID of runs whose places should not be asked for again, one per line: for example the run that stopped at its spending limit before it was through, so that this run takes up where it left off. Applies to the place IDs read from Place IDs from earlier runs.",
            "items": {
              "type": "string"
            }
          },
          "recentReputation": {
            "title": "Recent reputation (last 3, 6 and 12 months)",
            "type": "boolean",
            "description": "Turn on to add the average rating and the number of ratings for the last 3, 6 and 12 months, the rating trend (<code>up</code>, <code>down</code>, <code>flat</code>) and the share of reviews the owner answered. Costs extra for each delivered place that has ratings (see Pricing). A place nobody has rated is not charged for it.",
            "default": false
          },
          "ratingTrendFilter": {
            "title": "Rating trend",
            "enum": [
              "any",
              "down",
              "up",
              "flat"
            ],
            "type": "string",
            "description": "Keep only places whose rating is moving one way. <code>any</code>: no filter. <code>down</code>: the last 6 months average at least 0.3 stars below the 6 months before. <code>up</code>: at least 0.3 above. <code>flat</code>: in between. Left out: places with fewer than 5 ratings in either half-year or more than 2,400 reviews in 12 months. Free, but it turns recent reputation on, which is charged per place delivered, and the run takes longer.",
            "default": "any"
          },
          "maxReviews": {
            "title": "Reviews per place",
            "minimum": 0,
            "type": "integer",
            "description": "Enter how many reviews to attach to each place, up to 2,400; a larger number is read as 2,400. 0 attaches none. Each review comes with its stars, exact date, text, the owner's reply, photos and the ratings per aspect (food, service, atmosphere). Charged per review delivered.",
            "default": 0
          },
          "reviewsSort": {
            "title": "Review order",
            "enum": [
              "newest",
              "mostRelevant",
              "highestRanking",
              "lowestRanking"
            ],
            "type": "string",
            "description": "Choose which reviews come first when you attach reviews: <code>newest</code>, <code>mostRelevant</code>, <code>highestRanking</code> (highest rating first) or <code>lowestRanking</code> (lowest rating first). With <b>Reviews newer than</b>, keep <code>newest</code>: in any other order only the first reviews of that order are read and the older ones among them are dropped, so a place can come with fewer reviews than it has since that date.",
            "default": "newest"
          },
          "reviewsStartDate": {
            "title": "Reviews newer than",
            "type": "string",
            "description": "Enter a date as year-month-day (<code>2026-05-03</code>), a date and time such as <code>2026-05-03T20:00:00</code>, or a number with minutes, hours, days, weeks, months or years, such as <code>3 months</code>, to attach only reviews written after it. Anything else stops the run before anything is searched: no places are charged. <b>Reviews per place</b> must be above 0 and stays the upper limit. Keep <b>Review order</b> at Newest."
          },
          "scrapeReviewsPersonalData": {
            "title": "Reviewer names",
            "type": "boolean",
            "description": "Off by default: reviews come without the reviewer's name, profile link and review link. Turn on only if you have a lawful reason to process personal data (in the EU and UK, a legal basis under the GDPR).",
            "default": false
          },
          "website": {
            "title": "Website",
            "enum": [
              "allPlaces",
              "withWebsite",
              "withoutWebsite",
              "realWebsiteOnly",
              "noRealWebsite"
            ],
            "type": "string",
            "description": "Choose which places to keep by the link in their website field. <code>withWebsite</code>: any link. <code>withoutWebsite</code>: no link at all. <code>realWebsiteOnly</code>: a link that is not a known social, booking, directory or website-builder page. <code>noRealWebsite</code>: no link, or only such a page. Every place also gets <code>websiteType</code>: <code>none</code>, <code>social</code>, <code>platform</code> or <code>website</code>.",
            "default": "allPlaces"
          },
          "phoneRequired": {
            "title": "Only places with a phone number",
            "type": "boolean",
            "description": "Turn on to leave out places that list no phone number.",
            "default": false
          },
          "unclaimedOnly": {
            "title": "Only unclaimed profiles",
            "type": "boolean",
            "description": "Turn on to keep only places whose Google Business Profile shows no owner (<code>claimThisBusiness</code> is true). Places where this is not known are left out.",
            "default": false
          },
          "placeMinimumStars": {
            "title": "Minimum rating",
            "enum": [
              "",
              "two",
              "twoAndHalf",
              "three",
              "threeAndHalf",
              "four",
              "fourAndHalf"
            ],
            "type": "string",
            "description": "Keep only places rated at least this high: <code>two</code> (2 stars), <code>twoAndHalf</code> (2.5), <code>three</code> (3), <code>threeAndHalf</code> (3.5), <code>four</code> (4) or <code>fourAndHalf</code> (4.5). Leave empty for any rating (in JSON: leave the field out). Places without any rating are left out too.",
            "default": ""
          },
          "placeMaximumStars": {
            "title": "Maximum rating",
            "enum": [
              "",
              "two",
              "twoAndHalf",
              "three",
              "threeAndHalf",
              "four",
              "fourAndHalf"
            ],
            "type": "string",
            "description": "Keep only places rated at most this high: <code>two</code> (2 stars), <code>twoAndHalf</code> (2.5), <code>three</code> (3), <code>threeAndHalf</code> (3.5), <code>four</code> (4) or <code>fourAndHalf</code> (4.5). Leave empty for any rating (in JSON: leave the field out). Use it to find businesses with a weak rating. Places without any rating are left out too.",
            "default": ""
          },
          "minReviewsCount": {
            "title": "Minimum number of ratings",
            "minimum": 0,
            "type": "integer",
            "description": "Leave out places with fewer ratings than this number."
          },
          "maxReviewsCount": {
            "title": "Maximum number of ratings",
            "minimum": 0,
            "type": "integer",
            "description": "Leave out places with more ratings than this number. Handy for finding small or new businesses. 0 keeps only places that nobody has rated yet."
          },
          "categoryFilterWords": {
            "title": "Only these categories",
            "type": "array",
            "description": "Enter words, one per line. A place is kept only when one of its categories contains one of them as a piece of text: <b>dentist</b> keeps \"Dentist\" and \"Pediatric dentist\", and <b>bar</b> also keeps \"Barber shop\". Enter every word that fits: <b>coffee</b> alone leaves out a place whose only category is \"Cafe\". Use the language of the results; accents and capitals do not matter. With an area and no search term, the words are searched for.",
            "items": {
              "type": "string"
            }
          },
          "excludeCategories": {
            "title": "Leave out these categories",
            "type": "array",
            "description": "Enter words, one per line. A place is dropped when one of its categories contains one of them, for example <b>hotel</b>. Accents and capitals do not matter.",
            "items": {
              "type": "string"
            }
          },
          "searchMatching": {
            "title": "Name must match the search term",
            "enum": [
              "all",
              "only_includes",
              "only_exact"
            ],
            "type": "string",
            "description": "Choose this when you search for one brand or business name. <code>all</code>: keep every result. <code>only_includes</code>: the name contains the search term. <code>only_exact</code>: the name is the search term and nothing else. Capitals and accents do not matter. With several search terms, a place is compared with the term that found it.",
            "default": "all"
          },
          "excludeNameWords": {
            "title": "Leave out names containing",
            "type": "array",
            "description": "Enter words, one per line. A place is dropped when its name contains one of them, for example the names of chains you do not want. Accents and capitals do not matter.",
            "items": {
              "type": "string"
            }
          },
          "scrapePlaceDetailPage": {
            "title": "Star breakdown for every place",
            "type": "boolean",
            "description": "Turn on to read each place's own page and get the number of 1, 2, 3, 4 and 5 star ratings (<code>reviewsDistribution</code>). In a test every rated place got it (602 of 602); without it only a few places have the breakdown. It adds nothing else. Same price per place; the run takes about twice as long (25 seconds against 14 in a test).",
            "default": false
          },
          "scrapeContacts": {
            "title": "Emails and social profiles from the website",
            "type": "boolean",
            "description": "Turn on to read each place's own website (its home page and up to two of its contact, about or legal pages) and get the email addresses and social profiles (Facebook, Instagram, LinkedIn, X, YouTube, TikTok, Pinterest) it publishes. Places without a website of their own are skipped. No extra charge. The run takes longer: websites answer more slowly than Google.",
            "default": false
          },
          "customGeolocation": {
            "title": "Custom area (GeoJSON)",
            "type": "object",
            "description": "Enter a GeoJSON Polygon or MultiPolygon to search inside your own shape, or a Point with <code>radiusKm</code> (5 if left out) to search around a spot. What geojson.io exports (a Feature or a FeatureCollection) is read too; lines are refused. Coordinates are [longitude, latitude]. Leave <b>Area</b> empty when you use this: areas are added together. Example: <code>{\"type\":\"Point\",\"coordinates\":[-105.9378,35.687],\"radiusKm\":3}</code>"
          },
          "countryCode": {
            "title": "Country",
            "type": "string",
            "description": "Enter two letters, for example <b>us</b> or <b>es</b>, together with City, State, County or Postal code. Used when Area and More areas are empty, and for a postal code written alone in Area or More areas: it says which country the code is in. Next to any other area text it is ignored. On its own it searches the whole country, which is a very large run."
          },
          "state": {
            "title": "State or region",
            "type": "string",
            "description": "Enter a state, province or region, for example <b>Texas</b>. Used when Area and More areas are empty."
          },
          "county": {
            "title": "County",
            "type": "string",
            "description": "Enter a county, for example <b>Travis County</b>. Used when Area and More areas are empty."
          },
          "city": {
            "title": "City",
            "type": "string",
            "description": "Enter a city, for example <b>Austin</b>. Used when Area and More areas are empty."
          },
          "postalCode": {
            "title": "Postal code",
            "type": "string",
            "description": "Enter one postal or ZIP code, for example <b>78701</b>, together with Country: a code alone exists in several countries and stops the run. Used only when Area and More areas are empty. The search covers the part of the map where Google lists that code, and only places with that postal code are delivered (a longer form of the same code, such as 78701-1234, counts). Places that show no address (many service-area businesses) are left out."
          },
          "proxyConfiguration": {
            "title": "Proxy",
            "type": "object",
            "description": "Leave as it is. Proxy use is included in the price. If Google turns a request away, it is sent again over a residential address of Apify Proxy, so a run does not lose places. With proxy groups or your own proxies, the residential addresses are not used, and requests also leave from the server's own address unless you turn on <b>All requests to Google through the proxy</b>. Own proxies in JSON: <code>\"proxyUrls\": [\"http://...\"]</code>.",
            "default": {
              "useApifyProxy": true
            }
          },
          "proxyOnly": {
            "title": "All requests to Google through the proxy",
            "type": "boolean",
            "description": "Turn on only if every request to Google must leave through your proxy. Runs get slower. If <b>Proxy</b> holds no proxy, or the proxy cannot be set up, the run then stops at the start and no places are charged; with this box off it goes on from the server's own address, and a note says so when a proxy could not be set up. Area names are always looked up in OpenStreetMap directly.",
            "default": false
          },
          "maxConcurrency": {
            "title": "Requests at the same time",
            "minimum": 1,
            "maximum": 96,
            "type": "integer",
            "description": "Lower it only if you want a slower, gentler run.",
            "default": 64
          },
          "maxRunsAtOnce": {
            "title": "Runs at once in your account",
            "minimum": 0,
            "maximum": 100,
            "type": "integer",
            "description": "Leave empty to start straight away. With a number, this run first waits while that many earlier runs of this Actor are still working in your account, and starts when one of them ends. Google turns requests away by how many arrive at the same time, so several runs started together (by you, a schedule, an AI agent or another chat window) slow each other down and push traffic to the paid residential proxy. 3 is a good value for large jobs. Nothing is searched or charged while waiting; the wait is shown in the status message and in the COVERAGE record (waitedForSlotSeconds)."
          },
          "maxResidentialMegabytes": {
            "title": "Residential proxy allowance (MB)",
            "minimum": 0,
            "type": "integer",
            "description": "Leave empty for no limit. When Google turns away the standard addresses, a request is sent again through the residential proxy, which Apify bills per megabyte. With a number, the run stops using the residential proxy after that many megabytes and goes on with the standard addresses only: more slowly, waiting longer between tries, without dropping places on purpose. 300 is a good value for a whole region. The COVERAGE record shows residentialMegabytes and residentialCapReached."
          }
        }
      },
      "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "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
                  },
                  "PROXY_UNBLOCKER_UNITS": {
                    "type": "integer",
                    "example": 0
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}