Pay-per-call GIS tools for AI agents: coordinates, measurement, reprojection, geodata conversion.
Maintain this server? Claim it
Call this server's tools from your browser. Nothing to install.
Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.
Tool list from our last check. Connect live to refresh it.
Buy a pack of Aquedra Run credits (US$5, US$20, US$50, US$100; 1 credit = US$1), only when the user asked for it or authorized their wallet to spend. With method "card" the result has a checkout_url the person completes in their browser; this tool never charges a card. With method "usdc" and no payment, the result is an x402 payment request (isError, PaymentRequired in structuredContent); an x402 wallet pays by calling this tool again with the same arguments and the signed payment in params._meta["x402/payment"], and the result's _meta["x402/payment-response"] carries the settlement. If a result says a payment is pending, do not pay again: call again with the same payment.
Credit pack in US dollars; 1 credit = US$1.
card returns a checkout_url the person pays in their browser; usdc pays over x402.
This tool isn't marked read-only, so it may change something on the server or in an account you connected.
Pick your client. Values in capitals, like YOUR_TOKEN, are yours to fill in.
Run in a terminal
claude mcp add --transport http run https://r.aquedra.com/mcp
Buy a pack of Aquedra Run credits (US$5, US$20, US$50, US$100; 1 credit = US$1), only when the user asked for it or authorized their wallet to spend. With method "card" the result has a checkout_url the person completes in their browser; this tool never charges a card. With method "usdc" and no payment, the result is an x402 payment request (isError, PaymentRequired in structuredContent); an x402 wallet pays by calling this tool again with the same arguments and the signed payment in params._meta["x402/payment"], and the result's _meta["x402/payment-response"] carries the settlement. If a result says a payment is pending, do not pay again: call again with the same payment.
| Argument | Type | Description |
|---|---|---|
| method | string | card returns a checkout_url the person pays in their browser; usdc pays over x402. |
| pack_usd* | number | Credit pack in US dollars; 1 credit = US$1. |
{
"type": "object",
"$schema": "https://json-schema.org/draft/2020-12/schema",
"required": [
"pack_usd"
],
"properties": {
"method": {
"enum": [
"card",
"usdc"
],
"type": "string",
"default": "card",
"description": "card returns a checkout_url the person pays in their browser; usdc pays over x402."
},
"pack_usd": {
"enum": [
5,
20,
50,
100
],
"type": "number",
"description": "Credit pack in US dollars; 1 credit = US$1."
}
}
}Answers a chat with open models on Aquedra Run's own GPUs: qwen3-8b (reasons before answering, and those tokens count as output and use up max_tokens, so set max_tokens to at least 1024); qwen2.5-3b (small text model for simple tasks); qwen2.5-coder-7b (code); qwen2.5-vl-7b (reads data: images). It runs only on idle GPUs: if the GPUs are busy the call fails with gpu_busy and retry_after_seconds, and nothing is charged. Limits are 8192 tokens of context, up to 2048 output tokens (a larger max_tokens is lowered to that, and the result then has max_tokens_requested) and 1 MiB of arguments, with no tools, JSON mode or embeddings; qwen2.5-vl-7b takes up to 2 inline data: images of up to 512 KB each, which together must fit in the 1 MiB. Costs per million tokens (input/output): qwen3-8b US$0.18/US$0.70, qwen2.5-3b US$0.05/US$0.10, qwen2.5-coder-7b US$0.025/US$0.05, qwen2.5-vl-7b US$0.18/US$0.69; minimum US$0.0005 per call, taken from prepaid credits and charged only when the call works; prompts and answers are not stored. Set dry_run to true to get the maximum a call can cost and max_cost_usd to refuse a call that could cost more.
| Argument | Type | Description |
|---|---|---|
| n | any | Only 1 is supported. |
| seed | any | Integer seed for repeatable sampling. |
| stop | any | Up to 4 stop sequences of up to 64 characters each. |
| model | string | null | Model id, default qwen3-8b. See GET /v1/models for the ones on sale. |
| top_p | any | Nucleus sampling, 0 to 1. |
| dry_run | boolean |
Converts up to 1,000 points between decimal degrees (dd), degrees-minutes-seconds (dms) and UTM, and returns each point in the requested output formats, in the input order. To change the coordinate reference system of a GeoJSON use reproject_geojson. Takes up to 1,000 points per call (WGS84 latitude and longitude, or UTM zone, hemisphere, easting and northing). Costs US$0.001 per unit (up to 1,000 points) from prepaid credits; with the default 3 s it is charged only when it succeeds, and invalid input is never charged. Set dry_run to true to get the price without charging and max_cost_usd to refuse a call that would cost more; for heavier inputs set max_seconds from 4 to 30, where each second over the 3 included costs US$0.0005, the full time is held up front and the unused part refunded, and the price and the time used are charged if the call runs out of time or memory, or is cancelled while running.
| Argument | Type | Description |
|---|---|---|
| to* | array | Output formats to return for every point (1 to 3 of dd, dms, utm). |
| from* | string | Format of the input points: dd (decimal degrees), dms (degrees-minutes-seconds text) or utm. |
| points* | array | Up to 1000 points. Each is {lat, lon} for dd, a text for dms, or {zone, hemisphere, easting, northing} for utm, matching `from`. |
| dry_run | boolean | When true, return the price (cost_usd) and units of this call without running it or charging anything. |
| max_seconds | integer | Compute time limit in seconds, 1 to 30 (default 3; 1 to 3 all use the standard 3 s). The price includes 3 s of compute. From 4 to 30 (extended time) the call runs on a separate lane, where buffer accepts larger inputs, and each second over 3 costs the geo_compute_second price: the price plus all those seconds is held at the start (that is what dry_run reports and max_cost_usd is compared with), the seconds not used are refunded, and the response adds compute_ms and max_seconds. With extended time the price and the time used are charged if the call runs out of time or memory, or is cancelled while running: 422 operation_too_complex keeps the whole hold, 422 operation_too_large or 413 result_too_large (a result over 8 MiB) or 499 cancelled keep the price and the seconds used, and those errors carry cost_usd. Any other failure is refunded in full. |
Converts a geospatial file (CSV, KML, GPX, GeoJSON or a zipped Shapefile as base64 text) to GeoJSON, KML or CSV and returns the converted text with the feature count. To reproject or measure features that are already GeoJSON use reproject_geojson or measure_geojson. Takes text content up to 1 MiB, or a Shapefile zip of up to about 750 KB, within 1 MiB of arguments and up to 50,000 features and 200,000 vertices. Costs US$0.01 per file from prepaid credits; with the default 3 s it is charged only when it succeeds, and invalid input is never charged. Set dry_run to true to get the price without charging and max_cost_usd to refuse a call that would cost more; for heavier inputs set max_seconds from 4 to 30, where each second over the 3 included costs US$0.0005, the full time is held up front and the unused part refunded, and the price and the time used are charged if the call runs out of time or memory, or is cancelled while running.
| Argument | Type | Description |
|---|---|---|
| content* | string | The file content as text. Size limits: csv 1 MiB (at most 200 columns, 50,000 rows and 200,000 cells), kml 1 MiB, gpx 1 MiB, geojson 1 MiB. For shapefile, a base64-encoded .zip (a bare .shp is not accepted) of up to ~750 KB (the whole request must fit in 1 MiB), which may expand to at most 8 MiB of .shp/.dbf/.prj/.cpg parts. csv and kml output accept at most 200 distinct property keys; csv output at most 200,000 cells (features x keys), kml output at most 20,000 features and 80,000 cells. |
| dry_run | boolean | When true, return the price (cost_usd) and units of this call without running it or charging anything. |
| x_field | string | CSV only: name of the longitude (x) column. Detected automatically when omitted. |
| y_field | string |
Read the account's credit balance (balance_usd, in US dollars as decimal text), its level (trial or paid) and limits, whether the one-time trial credits were granted, whether credit purchases are open, and the most recent credit movements.
No arguments.
{
"type": "object",
"$schema": "https://json-schema.org/draft/2020-12/schema",
"properties": {}
}Measures the geodesic area, perimeter and length of each feature of a GeoJSON and returns them per feature with totals, in square meters and meters. To change the CRS use reproject_geojson, and to buffer, simplify or clean the geometry use transform_geojson. Takes a GeoJSON of up to 50,000 features and 200,000 vertices in WGS84 longitude and latitude, and up to 1 MiB of arguments. Costs US$0.001 per unit (up to 1,000 features and 10,000 vertices) from prepaid credits; with the default 3 s it is charged only when it succeeds, and invalid input is never charged. Set dry_run to true to get the price without charging and max_cost_usd to refuse a call that would cost more; for heavier inputs set max_seconds from 4 to 30, where each second over the 3 included costs US$0.0005, the full time is held up front and the unused part refunded, and the price and the time used are charged if the call runs out of time or memory, or is cancelled while running.
| Argument | Type | Description |
|---|---|---|
| dry_run | boolean | When true, return the price (cost_usd) and units of this call without running it or charging anything. |
| geojson* | object | GeoJSON object: a FeatureCollection, a Feature or a bare geometry, in WGS84 longitude/latitude unless a CRS is stated. Limits: 50,000 features and 200,000 vertices. An operation that runs past its compute or memory limit fails with 422 operation_too_complex or operation_too_large. |
| max_seconds | integer | Compute time limit in seconds, 1 to 30 (default 3; 1 to 3 all use the standard 3 s). The price includes 3 s of compute. From 4 to 30 (extended time) the call runs on a separate lane, where buffer accepts larger inputs, and each second over 3 costs the geo_compute_second price: the price plus all those seconds is held at the start (that is what dry_run reports and max_cost_usd is compared with), the seconds not used are refunded, and the response adds compute_ms and max_seconds. With extended time the price and the time used are charged if the call runs out of time or memory, or is cancelled while running: 422 operation_too_complex keeps the whole hold, 422 operation_too_large or 413 result_too_large (a result over 8 MiB) or 499 cancelled keep the price and the seconds used, and those errors carry cost_usd. Any other failure is refunded in full. |
Reprojects every coordinate of a GeoJSON from one CRS to another (EPSG:4326, 3857, 4674, 5361, 32718, 32719 or a WGS84 UTM zone) and returns the GeoJSON. To convert individual points to degrees-minutes-seconds or UTM text use convert_coordinates, and to read a CSV, KML, GPX or Shapefile use convert_geo_file. Takes a GeoJSON of up to 50,000 features and 200,000 vertices, and up to 1 MiB of arguments. Costs US$0.001 per unit (up to 1,000 features and 10,000 vertices) from prepaid credits; with the default 3 s it is charged only when it succeeds, and invalid input is never charged. Set dry_run to true to get the price without charging and max_cost_usd to refuse a call that would cost more; for heavier inputs set max_seconds from 4 to 30, where each second over the 3 included costs US$0.0005, the full time is held up front and the unused part refunded, and the price and the time used are charged if the call runs out of time or memory, or is cancelled while running.
| Argument | Type | Description |
|---|---|---|
| to_crs* | string | CRS to convert the coordinates to, as EPSG:<n>. |
| dry_run | boolean | When true, return the price (cost_usd) and units of this call without running it or charging anything. |
| geojson* | object | GeoJSON object: a FeatureCollection, a Feature or a bare geometry, in WGS84 longitude/latitude unless a CRS is stated. Limits: 50,000 features and 200,000 vertices. An operation that runs past its compute or memory limit fails with 422 operation_too_complex or operation_too_large. |
| from_crs* | string | CRS of the input coordinates, as EPSG:<n>. |
Applies one operation to a GeoJSON (buffer, simplify, centroid, bbox, convex_hull or clean) and returns the resulting GeoJSON. To measure areas or lengths use measure_geojson, and to change the CRS use reproject_geojson. Takes up to 50,000 features and 200,000 vertices and 1 MiB of arguments, and buffer takes up to 1,000 features and 4,000 vertices (5,000 and 20,000 with max_seconds over 3). Costs US$0.001 per unit (up to 1,000 features and 10,000 vertices) from prepaid credits; with the default 3 s it is charged only when it succeeds, and invalid input is never charged. Set dry_run to true to get the price without charging and max_cost_usd to refuse a call that would cost more; for heavier inputs set max_seconds from 4 to 30, where each second over the 3 included costs US$0.0005, the full time is held up front and the unused part refunded, and the price and the time used are charged if the call runs out of time or memory, or is cancelled while running.
| Argument | Type | Description |
|---|---|---|
| dry_run | boolean | When true, return the price (cost_usd) and units of this call without running it or charging anything. |
| geojson* | object | GeoJSON object: a FeatureCollection, a Feature or a bare geometry, in WGS84 longitude/latitude unless a CRS is stated. Limits: 50,000 features and 200,000 vertices. An operation that runs past its compute or memory limit fails with 422 operation_too_complex or operation_too_large. |
| operation* | string | Operation: buffer, simplify, centroid, bbox, convex_hull, or clean (drops point features with empty, non-numeric, swapped, out-of-range or 0,0 coordinates). |
| distance_m | number | Buffer distance in meters (0 to 100000). Required for buffer. Buffer accepts at most 1,000 features, 4,000 vertices and 1,000 MultiPoint positions; with max_seconds above 3 (extended time), 5,000 features, 20,000 vertices and 5,000 MultiPoint positions. |
We read every tool's name, description and inputs the way the model will, looking for instructions hidden from you. A clean result means no warning signs, not a guarantee. Scanned Nov 22, 2026.
| When true, return the most this call can cost (cost_usd, the hold) and the max_tokens it assumes, without running it or charging anything. |
| messages* | array | The conversation, 1 to 64 messages. |
| max_tokens | any | Most tokens to generate, default 1024. A larger value than the output cap (max_output_tokens in GET /v1/models) is lowered to it, and the response says so in max_tokens and max_tokens_requested. qwen3-8b's reasoning counts toward it: send at least 1024. |
| temperature | any | Sampling temperature, 0 to 2. |
| max_cost_usd | number | string | The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or "0.01"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged. |
| response_format | any | Only {"type":"text"} is supported. |
| max_completion_tokens | any | Same as max_tokens; wins when both are sent. |
{
"type": "object",
"$schema": "https://json-schema.org/draft/2020-12/schema",
"required": [
"messages"
],
"properties": {
"n": {
"anyOf": [
{
"type": "number",
"const": 1
},
{
"type": "null"
}
],
"description": "Only 1 is supported."
},
"seed": {
"anyOf": [
{
"type": "integer",
"maximum": 9007199254740991,
"minimum": -9007199254740991
},
{
"type": "null"
}
],
"description": "Integer seed for repeatable sampling."
},
"stop": {
"anyOf": [
{
"anyOf": [
{
"type": "string",
"maxLength": 64
},
{
"type": "array",
"items": {
"type": "string",
"maxLength": 64
},
"maxItems": 4
}
]
},
{
"type": "null"
}
],
"description": "Up to 4 stop sequences of up to 64 characters each."
},
"model": {
"type": [
"string",
"null"
],
"description": "Model id, default qwen3-8b. See GET /v1/models for the ones on sale."
},
"top_p": {
"anyOf": [
{
"type": "number",
"maximum": 1,
"minimum": 0
},
{
"type": "null"
}
],
"description": "Nucleus sampling, 0 to 1."
},
"dry_run": {
"type": "boolean",
"description": "When true, return the most this call can cost (cost_usd, the hold) and the max_tokens it assumes, without running it or charging anything."
},
"messages": {
"type": "array",
"items": {
"type": "object",
"required": [
"role",
"content"
],
"properties": {
"role": {
"enum": [
"system",
"user",
"assistant"
],
"type": "string",
"description": "Who wrote the message. The tool role is not supported."
},
"content": {
"anyOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"oneOf": [
{
"type": "object",
"required": [
"type",
"text"
],
"properties": {
"text": {
"type": "string"
},
"type": {
"type": "string",
"const": "text"
}
},
"description": "A text part."
},
{
"type": "object",
"required": [
"type",
"image_url"
],
"properties": {
"type": {
"type": "string",
"const": "image_url"
},
"image_url": {
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string"
}
}
}
},
"description": "An inline image as a data:image/png|jpeg|webp;base64 URL (qwen2.5-vl-7b only, up to 2 images of 512 KB each, which together must fit in the 1 MiB request)."
}
]
}
}
],
"description": "The message text, or a list of text and image parts."
}
}
},
"maxItems": 64,
"minItems": 1,
"description": "The conversation, 1 to 64 messages."
},
"max_tokens": {
"anyOf": [
{
"type": "integer",
"maximum": 9007199254740991,
"minimum": 1
},
{
"type": "null"
}
],
"description": "Most tokens to generate, default 1024. A larger value than the output cap (max_output_tokens in GET /v1/models) is lowered to it, and the response says so in max_tokens and max_tokens_requested. qwen3-8b's reasoning counts toward it: send at least 1024."
},
"temperature": {
"anyOf": [
{
"type": "number",
"maximum": 2,
"minimum": 0
},
{
"type": "null"
}
],
"description": "Sampling temperature, 0 to 2."
},
"max_cost_usd": {
"type": [
"number",
"string"
],
"description": "The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or \"0.01\"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged."
},
"response_format": {
"anyOf": [
{
"type": "object",
"required": [
"type"
],
"properties": {
"type": {
"type": "string",
"const": "text"
}
}
},
{
"type": "null"
}
],
"description": "Only {\"type\":\"text\"} is supported."
},
"max_completion_tokens": {
"anyOf": [
{
"type": "integer",
"maximum": 9007199254740991,
"minimum": 1
},
{
"type": "null"
}
],
"description": "Same as max_tokens; wins when both are sent."
}
}
}| max_cost_usd | number | string | The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or "0.01"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged. |
{
"type": "object",
"$schema": "https://json-schema.org/draft/2020-12/schema",
"required": [
"from",
"to",
"points"
],
"properties": {
"to": {
"type": "array",
"items": {
"enum": [
"dd",
"dms",
"utm"
],
"type": "string"
},
"maxItems": 3,
"minItems": 1,
"description": "Output formats to return for every point (1 to 3 of dd, dms, utm)."
},
"from": {
"enum": [
"dd",
"dms",
"utm"
],
"type": "string",
"description": "Format of the input points: dd (decimal degrees), dms (degrees-minutes-seconds text) or utm."
},
"points": {
"type": "array",
"items": {
"anyOf": [
{
"type": "object",
"required": [
"lat",
"lon"
],
"properties": {
"lat": {
"type": "number",
"maximum": 90,
"minimum": -90,
"description": "Latitude in decimal degrees (-90 to 90)."
},
"lon": {
"type": "number",
"maximum": 180,
"minimum": -180,
"description": "Longitude in decimal degrees (-180 to 180)."
}
}
},
{
"type": "string",
"maxLength": 200,
"minLength": 1,
"description": "Latitude then longitude as degrees-minutes-seconds text, e.g. 33°26'56\"S 70°40'09\"W (separated by a space, comma or semicolon)."
},
{
"type": "object",
"required": [
"zone",
"hemisphere",
"easting",
"northing"
],
"properties": {
"zone": {
"type": "integer",
"maximum": 60,
"minimum": 1,
"description": "UTM zone number (1 to 60)."
},
"easting": {
"type": "number",
"description": "UTM easting in meters."
},
"northing": {
"type": "number",
"description": "UTM northing in meters."
},
"hemisphere": {
"enum": [
"N",
"S"
],
"type": "string",
"description": "UTM hemisphere: N or S."
}
}
}
]
},
"maxItems": 1000,
"minItems": 1,
"description": "Up to 1000 points. Each is {lat, lon} for dd, a text for dms, or {zone, hemisphere, easting, northing} for utm, matching `from`."
},
"dry_run": {
"type": "boolean",
"description": "When true, return the price (cost_usd) and units of this call without running it or charging anything."
},
"max_seconds": {
"type": "integer",
"maximum": 30,
"minimum": 1,
"description": "Compute time limit in seconds, 1 to 30 (default 3; 1 to 3 all use the standard 3 s). The price includes 3 s of compute. From 4 to 30 (extended time) the call runs on a separate lane, where buffer accepts larger inputs, and each second over 3 costs the geo_compute_second price: the price plus all those seconds is held at the start (that is what dry_run reports and max_cost_usd is compared with), the seconds not used are refunded, and the response adds compute_ms and max_seconds. With extended time the price and the time used are charged if the call runs out of time or memory, or is cancelled while running: 422 operation_too_complex keeps the whole hold, 422 operation_too_large or 413 result_too_large (a result over 8 MiB) or 499 cancelled keep the price and the seconds used, and those errors carry cost_usd. Any other failure is refunded in full."
},
"max_cost_usd": {
"type": [
"number",
"string"
],
"description": "The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or \"0.01\"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged."
}
},
"description": "Convert points between decimal degrees, degrees-minutes-seconds and UTM."
}| CSV only: name of the latitude (y) column. Detected automatically when omitted. |
| max_seconds | integer | Compute time limit in seconds, 1 to 30 (default 3; 1 to 3 all use the standard 3 s). The price includes 3 s of compute. From 4 to 30 (extended time) the call runs on a separate lane, where buffer accepts larger inputs, and each second over 3 costs the geo_compute_second price: the price plus all those seconds is held at the start (that is what dry_run reports and max_cost_usd is compared with), the seconds not used are refunded, and the response adds compute_ms and max_seconds. With extended time the price and the time used are charged if the call runs out of time or memory, or is cancelled while running: 422 operation_too_complex keeps the whole hold, 422 operation_too_large or 413 result_too_large (a result over 8 MiB) or 499 cancelled keep the price and the seconds used, and those errors carry cost_usd. Any other failure is refunded in full. |
| input_format* | string | Format of `content`. |
| max_cost_usd | number | string | The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or "0.01"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged. |
| output_format* | string | Format to convert to. |
{
"type": "object",
"$schema": "https://json-schema.org/draft/2020-12/schema",
"required": [
"input_format",
"content",
"output_format"
],
"properties": {
"content": {
"type": "string",
"minLength": 1,
"description": "The file content as text. Size limits: csv 1 MiB (at most 200 columns, 50,000 rows and 200,000 cells), kml 1 MiB, gpx 1 MiB, geojson 1 MiB. For shapefile, a base64-encoded .zip (a bare .shp is not accepted) of up to ~750 KB (the whole request must fit in 1 MiB), which may expand to at most 8 MiB of .shp/.dbf/.prj/.cpg parts. csv and kml output accept at most 200 distinct property keys; csv output at most 200,000 cells (features x keys), kml output at most 20,000 features and 80,000 cells."
},
"dry_run": {
"type": "boolean",
"description": "When true, return the price (cost_usd) and units of this call without running it or charging anything."
},
"x_field": {
"type": "string",
"maxLength": 200,
"minLength": 1,
"description": "CSV only: name of the longitude (x) column. Detected automatically when omitted."
},
"y_field": {
"type": "string",
"maxLength": 200,
"minLength": 1,
"description": "CSV only: name of the latitude (y) column. Detected automatically when omitted."
},
"max_seconds": {
"type": "integer",
"maximum": 30,
"minimum": 1,
"description": "Compute time limit in seconds, 1 to 30 (default 3; 1 to 3 all use the standard 3 s). The price includes 3 s of compute. From 4 to 30 (extended time) the call runs on a separate lane, where buffer accepts larger inputs, and each second over 3 costs the geo_compute_second price: the price plus all those seconds is held at the start (that is what dry_run reports and max_cost_usd is compared with), the seconds not used are refunded, and the response adds compute_ms and max_seconds. With extended time the price and the time used are charged if the call runs out of time or memory, or is cancelled while running: 422 operation_too_complex keeps the whole hold, 422 operation_too_large or 413 result_too_large (a result over 8 MiB) or 499 cancelled keep the price and the seconds used, and those errors carry cost_usd. Any other failure is refunded in full."
},
"input_format": {
"enum": [
"csv",
"kml",
"gpx",
"geojson",
"shapefile"
],
"type": "string",
"description": "Format of `content`."
},
"max_cost_usd": {
"type": [
"number",
"string"
],
"description": "The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or \"0.01\"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged."
},
"output_format": {
"enum": [
"geojson",
"kml",
"csv"
],
"type": "string",
"description": "Format to convert to."
}
},
"description": "Convert a geospatial file between CSV, KML, GPX, GeoJSON and Shapefile."
}| max_cost_usd | number | string | The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or "0.01"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged. |
{
"type": "object",
"$schema": "https://json-schema.org/draft/2020-12/schema",
"required": [
"geojson"
],
"properties": {
"dry_run": {
"type": "boolean",
"description": "When true, return the price (cost_usd) and units of this call without running it or charging anything."
},
"geojson": {
"type": "object",
"required": [
"type"
],
"properties": {
"type": {
"type": "string"
}
},
"description": "GeoJSON object: a FeatureCollection, a Feature or a bare geometry, in WGS84 longitude/latitude unless a CRS is stated. Limits: 50,000 features and 200,000 vertices. An operation that runs past its compute or memory limit fails with 422 operation_too_complex or operation_too_large.",
"additionalProperties": {}
},
"max_seconds": {
"type": "integer",
"maximum": 30,
"minimum": 1,
"description": "Compute time limit in seconds, 1 to 30 (default 3; 1 to 3 all use the standard 3 s). The price includes 3 s of compute. From 4 to 30 (extended time) the call runs on a separate lane, where buffer accepts larger inputs, and each second over 3 costs the geo_compute_second price: the price plus all those seconds is held at the start (that is what dry_run reports and max_cost_usd is compared with), the seconds not used are refunded, and the response adds compute_ms and max_seconds. With extended time the price and the time used are charged if the call runs out of time or memory, or is cancelled while running: 422 operation_too_complex keeps the whole hold, 422 operation_too_large or 413 result_too_large (a result over 8 MiB) or 499 cancelled keep the price and the seconds used, and those errors carry cost_usd. Any other failure is refunded in full."
},
"max_cost_usd": {
"type": [
"number",
"string"
],
"description": "The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or \"0.01\"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged."
}
},
"description": "Measure geodesic area (m²), perimeter and length (m) of each feature in a GeoJSON. Polygons get area_m2 and perimeter_m, lines get length_m, points and GeometryCollection features get no measures."
}| max_seconds |
| integer |
| Compute time limit in seconds, 1 to 30 (default 3; 1 to 3 all use the standard 3 s). The price includes 3 s of compute. From 4 to 30 (extended time) the call runs on a separate lane, where buffer accepts larger inputs, and each second over 3 costs the geo_compute_second price: the price plus all those seconds is held at the start (that is what dry_run reports and max_cost_usd is compared with), the seconds not used are refunded, and the response adds compute_ms and max_seconds. With extended time the price and the time used are charged if the call runs out of time or memory, or is cancelled while running: 422 operation_too_complex keeps the whole hold, 422 operation_too_large or 413 result_too_large (a result over 8 MiB) or 499 cancelled keep the price and the seconds used, and those errors carry cost_usd. Any other failure is refunded in full. |
| max_cost_usd | number | string | The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or "0.01"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged. |
{
"type": "object",
"$schema": "https://json-schema.org/draft/2020-12/schema",
"required": [
"geojson",
"from_crs",
"to_crs"
],
"properties": {
"to_crs": {
"type": "string",
"pattern": "^EPSG:\\d+$",
"description": "CRS to convert the coordinates to, as EPSG:<n>."
},
"dry_run": {
"type": "boolean",
"description": "When true, return the price (cost_usd) and units of this call without running it or charging anything."
},
"geojson": {
"type": "object",
"required": [
"type"
],
"properties": {
"type": {
"type": "string"
}
},
"description": "GeoJSON object: a FeatureCollection, a Feature or a bare geometry, in WGS84 longitude/latitude unless a CRS is stated. Limits: 50,000 features and 200,000 vertices. An operation that runs past its compute or memory limit fails with 422 operation_too_complex or operation_too_large.",
"additionalProperties": {}
},
"from_crs": {
"type": "string",
"pattern": "^EPSG:\\d+$",
"description": "CRS of the input coordinates, as EPSG:<n>."
},
"max_seconds": {
"type": "integer",
"maximum": 30,
"minimum": 1,
"description": "Compute time limit in seconds, 1 to 30 (default 3; 1 to 3 all use the standard 3 s). The price includes 3 s of compute. From 4 to 30 (extended time) the call runs on a separate lane, where buffer accepts larger inputs, and each second over 3 costs the geo_compute_second price: the price plus all those seconds is held at the start (that is what dry_run reports and max_cost_usd is compared with), the seconds not used are refunded, and the response adds compute_ms and max_seconds. With extended time the price and the time used are charged if the call runs out of time or memory, or is cancelled while running: 422 operation_too_complex keeps the whole hold, 422 operation_too_large or 413 result_too_large (a result over 8 MiB) or 499 cancelled keep the price and the seconds used, and those errors carry cost_usd. Any other failure is refunded in full."
},
"max_cost_usd": {
"type": [
"number",
"string"
],
"description": "The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or \"0.01\"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged."
}
},
"description": "Reproject every coordinate of a GeoJSON between two coordinate reference systems."
}| max_seconds | integer | Compute time limit in seconds, 1 to 30 (default 3; 1 to 3 all use the standard 3 s). The price includes 3 s of compute. From 4 to 30 (extended time) the call runs on a separate lane, where buffer accepts larger inputs, and each second over 3 costs the geo_compute_second price: the price plus all those seconds is held at the start (that is what dry_run reports and max_cost_usd is compared with), the seconds not used are refunded, and the response adds compute_ms and max_seconds. With extended time the price and the time used are charged if the call runs out of time or memory, or is cancelled while running: 422 operation_too_complex keeps the whole hold, 422 operation_too_large or 413 result_too_large (a result over 8 MiB) or 499 cancelled keep the price and the seconds used, and those errors carry cost_usd. Any other failure is refunded in full. |
| tolerance_m | number | Simplify tolerance in meters, converted to degrees approximately (1 degree is about 111,320 m), so it is less exact away from the equator. Defaults to 10. |
| max_cost_usd | number | string | The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or "0.01"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged. |
{
"type": "object",
"$schema": "https://json-schema.org/draft/2020-12/schema",
"required": [
"geojson",
"operation"
],
"properties": {
"dry_run": {
"type": "boolean",
"description": "When true, return the price (cost_usd) and units of this call without running it or charging anything."
},
"geojson": {
"type": "object",
"required": [
"type"
],
"properties": {
"type": {
"type": "string"
}
},
"description": "GeoJSON object: a FeatureCollection, a Feature or a bare geometry, in WGS84 longitude/latitude unless a CRS is stated. Limits: 50,000 features and 200,000 vertices. An operation that runs past its compute or memory limit fails with 422 operation_too_complex or operation_too_large.",
"additionalProperties": {}
},
"operation": {
"enum": [
"buffer",
"simplify",
"centroid",
"bbox",
"convex_hull",
"clean"
],
"type": "string",
"description": "Operation: buffer, simplify, centroid, bbox, convex_hull, or clean (drops point features with empty, non-numeric, swapped, out-of-range or 0,0 coordinates)."
},
"distance_m": {
"type": "number",
"maximum": 100000,
"minimum": 0,
"description": "Buffer distance in meters (0 to 100000). Required for buffer. Buffer accepts at most 1,000 features, 4,000 vertices and 1,000 MultiPoint positions; with max_seconds above 3 (extended time), 5,000 features, 20,000 vertices and 5,000 MultiPoint positions."
},
"max_seconds": {
"type": "integer",
"maximum": 30,
"minimum": 1,
"description": "Compute time limit in seconds, 1 to 30 (default 3; 1 to 3 all use the standard 3 s). The price includes 3 s of compute. From 4 to 30 (extended time) the call runs on a separate lane, where buffer accepts larger inputs, and each second over 3 costs the geo_compute_second price: the price plus all those seconds is held at the start (that is what dry_run reports and max_cost_usd is compared with), the seconds not used are refunded, and the response adds compute_ms and max_seconds. With extended time the price and the time used are charged if the call runs out of time or memory, or is cancelled while running: 422 operation_too_complex keeps the whole hold, 422 operation_too_large or 413 result_too_large (a result over 8 MiB) or 499 cancelled keep the price and the seconds used, and those errors carry cost_usd. Any other failure is refunded in full."
},
"tolerance_m": {
"type": "number",
"maximum": 100000,
"description": "Simplify tolerance in meters, converted to degrees approximately (1 degree is about 111,320 m), so it is less exact away from the equator. Defaults to 10.",
"exclusiveMinimum": 0
},
"max_cost_usd": {
"type": [
"number",
"string"
],
"description": "The most this call may cost, in USD, as a number or decimal text with at most 6 decimals (e.g. 0.01 or \"0.01\"). A call that would cost more is refused with 402 max_cost_exceeded and nothing is charged."
}
},
"description": "Apply one geometric operation to a GeoJSON and return the resulting GeoJSON."
}