Osmosis - gRPC Gateway docs

v1.0.0

Base URL

https://osmo.nownodes.io

A REST interface for state queries, legacy transactions

Authentication

api-keyAuthapiKey

API Key: api-key in header

API Reference

Epochs

CurrentEpoch provide current epoch of specified identifier

GET

https://osmo.nownodes.io/osmosis/epochs/v1beta1/current_epoch

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

identifierstringquery

Response

200OK

A successful response.

default

An unexpected error response.

CurrentEpoch provide current epoch of specified identifier

curl -X GET 'https://osmo.nownodes.io/osmosis/epochs/v1beta1/current_epoch'

const response = await fetch('https://osmo.nownodes.io/osmosis/epochs/v1beta1/current_epoch', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/epochs/v1beta1/current_epoch')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/epochs/v1beta1/current_epoch')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/epochs/v1beta1/current_epoch', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/epochs/v1beta1/current_epoch";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/epochs/v1beta1/current_epoch', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/epochs/v1beta1/current_epoch')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/epochs/v1beta1/current_epoch')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "current_epoch": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

EpochInfos provide running epochInfos

GET

https://osmo.nownodes.io/osmosis/epochs/v1beta1/epochs

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

EpochInfos provide running epochInfos

curl -X GET 'https://osmo.nownodes.io/osmosis/epochs/v1beta1/epochs'

const response = await fetch('https://osmo.nownodes.io/osmosis/epochs/v1beta1/epochs', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/epochs/v1beta1/epochs')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/epochs/v1beta1/epochs')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/epochs/v1beta1/epochs', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/epochs/v1beta1/epochs";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/epochs/v1beta1/epochs', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/epochs/v1beta1/epochs')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/epochs/v1beta1/epochs')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "epochs": [
    {
      "identifier": "string",
      "start_time": "2024-01-15T09:30:00Z",
      "duration": "string",
      "current_epoch": "string",
      "current_epoch_start_time": "2024-01-15T09:30:00Z",
      "epoch_counting_started": true,
      "current_epoch_start_height": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Gamm

CFMMConcentratedPoolLinks returns migration links between CFMM and Concentrated pools.

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/cfmm_concentrated_pool_links

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

CFMMConcentratedPoolLinks returns migration links between CFMM and Concentrated pools.

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/cfmm_concentrated_pool_links'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/cfmm_concentrated_pool_links', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/cfmm_concentrated_pool_links')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/cfmm_concentrated_pool_links')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/cfmm_concentrated_pool_links', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/cfmm_concentrated_pool_links";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/cfmm_concentrated_pool_links', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/cfmm_concentrated_pool_links')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/cfmm_concentrated_pool_links')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "migration_records": {
    "balancer_to_concentrated_pool_links": [
      {
        "balancer_pool_id": "string",
        "cl_pool_id": "string"
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ConcentratedPoolIdLinkFromBalancer returns the pool id of the concentrated pool that is linked with the given CFMM pool.

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/concentrated_pool_id_link_from_cfmm/{cfmm_pool_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

cfmm_pool_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

ConcentratedPoolIdLinkFromBalancer returns the pool id of the concentrated pool that is linked with the given CFMM pool.

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/concentrated_pool_id_link_from_cfmm/{cfmm_pool_id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/concentrated_pool_id_link_from_cfmm/{cfmm_pool_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/concentrated_pool_id_link_from_cfmm/{cfmm_pool_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/concentrated_pool_id_link_from_cfmm/{cfmm_pool_id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/concentrated_pool_id_link_from_cfmm/{cfmm_pool_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/concentrated_pool_id_link_from_cfmm/{cfmm_pool_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/concentrated_pool_id_link_from_cfmm/{cfmm_pool_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/concentrated_pool_id_link_from_cfmm/{cfmm_pool_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/concentrated_pool_id_link_from_cfmm/{cfmm_pool_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "concentrated_pool_id": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

PoolsWithFilter allows you to query specific pools with requested parameters

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/filtered_pools

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

min_liquiditystringquery

String of the coins in single string seperated by comma. Ex) 10uatom,100uosmo.

pool_typestringquery

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalbooleanquery

count_total is set to true to indicate that the result set should include a count of the total number of items available for pagination in UIs. count_total is only respected when offset is used. It is ignored when key is set.

pagination.reversebooleanquery

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response.

PoolsWithFilter allows you to query specific pools with requested parameters

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/filtered_pools'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/filtered_pools', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/filtered_pools')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/filtered_pools')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/filtered_pools', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/filtered_pools";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/filtered_pools', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/filtered_pools')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/filtered_pools')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "pools": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Deprecated: please use the alternative in x/poolmanager

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/num_pools

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Deprecated: please use the alternative in x/poolmanager

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/num_pools'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/num_pools', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/num_pools')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/num_pools')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/num_pools', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/num_pools";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/num_pools', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/num_pools')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/num_pools')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "num_pools": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

PoolType returns the type of the pool. Returns "Balancer" as a string literal when the pool is a balancer pool. Errors if the pool is failed to be type caseted.

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/pool_type/{pool_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

PoolType returns the type of the pool. Returns "Balancer" as a string literal when the pool is a balancer pool. Errors if the pool is failed to be type caseted.

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/pool_type/{pool_id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pool_type/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pool_type/{pool_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pool_type/{pool_id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pool_type/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/pool_type/{pool_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pool_type/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pool_type/{pool_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pool_type/{pool_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "pool_type": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalbooleanquery

pagination.reversebooleanquery

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response.

GET /osmosis/gamm/v1beta1/pools

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "pools": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Deprecated: please use the alternative in x/poolmanager

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Deprecated: please use the alternative in x/poolmanager

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "pool": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

share_in_amountstringquery

Response

200OK

A successful response.

default

An unexpected error response.

GET /osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/exit_swap_share_amount_in')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "tokens_out": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

GET /osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/join_swap_exact_in')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "share_out_amount": "string",
  "tokens_out": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

GET /osmosis/gamm/v1beta1/pools/{pool_id}/params

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/params'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/params')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/params";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "params": {
    "type_url": "string",
    "value": "dGVzdA=="
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

SpotPrice defines a gRPC query handler that returns the spot price given a base denomination and a quote denomination.

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/prices

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

base_asset_denomstringquery

quote_asset_denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

SpotPrice defines a gRPC query handler that returns the spot price given a base denomination and a quote denomination.

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/prices'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/prices', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/prices')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/prices')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/prices', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/prices";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/prices', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/prices')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/prices')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "spot_price": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Deprecated: please use the alternative in x/poolmanager

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_pool_liquidity

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Deprecated: please use the alternative in x/poolmanager

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_pool_liquidity'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_pool_liquidity', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_pool_liquidity')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_pool_liquidity')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_pool_liquidity', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_pool_liquidity";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_pool_liquidity', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_pool_liquidity')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_pool_liquidity')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "liquidity": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_shares

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

GET /osmosis/gamm/v1beta1/pools/{pool_id}/total_shares

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_shares'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_shares', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_shares')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_shares')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_shares', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_shares";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_shares', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_shares')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/pools/{pool_id}/total_shares')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "total_shares": {
    "denom": "string",
    "amount": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/total_liquidity

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

GET /osmosis/gamm/v1beta1/total_liquidity

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/total_liquidity'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/total_liquidity', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/total_liquidity')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/total_liquidity')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/total_liquidity', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/total_liquidity";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/total_liquidity', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/total_liquidity')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/total_liquidity')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "liquidity": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Deprecated: please use the alternative in x/poolmanager

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_in

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

senderstringquery

token_instringquery

Response

200OK

A successful response.

default

An unexpected error response.

Deprecated: please use the alternative in x/poolmanager

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_in'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_in', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_in')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_in')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_in', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_in";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_in', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_in')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_in')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "token_out_amount": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Deprecated: please use the alternative in x/poolmanager

GET

https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_out

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

senderstringquery

token_outstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Deprecated: please use the alternative in x/poolmanager

curl -X GET 'https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_out'

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_out', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_out')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_out')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_out', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_out";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_out', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_out')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/gamm/v1beta1/{pool_id}/estimate/swap_exact_amount_out')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "token_in_amount": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Incentives

ActiveGauges returns active gauges

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalbooleanquery

pagination.reversebooleanquery

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response.

ActiveGauges returns active gauges

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "data": [
    {
      "id": "string",
      "is_perpetual": true,
      "distribute_to": {
        "lock_query_type": "ByDuration",
        "denom": "string",
        "duration": "string",
        "timestamp": "2024-01-15T09:30:00Z"
      },
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "start_time": "2024-01-15T09:30:00Z",
      "num_epochs_paid_over": "string",
      "filled_epochs": "string",
      "distributed_coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ActiveGaugesPerDenom returns active gauges by denom

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges_per_denom

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringquery

Desired denom when querying active gagues.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalbooleanquery

pagination.reversebooleanquery

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response.

ActiveGaugesPerDenom returns active gauges by denom

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges_per_denom'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges_per_denom', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges_per_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges_per_denom')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges_per_denom', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges_per_denom";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges_per_denom', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges_per_denom')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/active_gauges_per_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "data": [
    {
      "id": "string",
      "is_perpetual": true,
      "distribute_to": {
        "lock_query_type": "ByDuration",
        "denom": "string",
        "duration": "string",
        "timestamp": "2024-01-15T09:30:00Z"
      },
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "start_time": "2024-01-15T09:30:00Z",
      "num_epochs_paid_over": "string",
      "filled_epochs": "string",
      "distributed_coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

AllGroups returns all groups

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

AllGroups returns all groups

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "groups": [
    {
      "group_gauge_id": "string",
      "internal_gauge_info": {
        "total_weight": "string",
        "gauge_records": [
          {
            "gauge_id": "string",
            "current_weight": "string",
            "cumulative_weight": "string"
          }
        ]
      },
      "splitting_policy": "ByVolume"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

AllGroupsGauges returns all group gauges

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_gauges

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

AllGroupsGauges returns all group gauges

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_gauges'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_gauges', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_gauges')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_gauges')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_gauges', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_gauges";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_gauges', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_gauges')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_gauges')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "gauges": [
    {
      "id": "string",
      "is_perpetual": true,
      "distribute_to": {
        "lock_query_type": "ByDuration",
        "denom": "string",
        "duration": "string",
        "timestamp": "2024-01-15T09:30:00Z"
      },
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "start_time": "2024-01-15T09:30:00Z",
      "num_epochs_paid_over": "string",
      "filled_epochs": "string",
      "distributed_coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ]
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

AllGroupsWithGauge returns all groups with their group gauge

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_with_gauge

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

AllGroupsWithGauge returns all groups with their group gauge

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_with_gauge'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_with_gauge', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_with_gauge')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_with_gauge')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_with_gauge', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_with_gauge";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_with_gauge', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_with_gauge')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/all_groups_with_gauge')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "groups_with_gauge": [
    {
      "group": {
        "group_gauge_id": "string",
        "internal_gauge_info": {
          "total_weight": "string",
          "gauge_records": [
            {
              "gauge_id": "string",
              "current_weight": "string",
              "cumulative_weight": "string"
            }
          ]
        },
        "splitting_policy": "ByVolume"
      },
      "gauge": {
        "id": "string",
        "is_perpetual": true,
        "distribute_to": {
          "lock_query_type": "ByDuration",
          "denom": "string",
          "duration": "string",
          "timestamp": "2024-01-15T09:30:00Z"
        },
        "coins": [
          {
            "denom": "string",
            "amount": "string"
          }
        ],
        "start_time": "2024-01-15T09:30:00Z",
        "num_epochs_paid_over": "string",
        "filled_epochs": "string",
        "distributed_coins": [
          {
            "denom": "string",
            "amount": "string"
          }
        ]
      }
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

CurrentWeightByGroupGaugeID returns the current weight since the the last epoch given a group gauge ID

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/current_weight_by_group_gauge_id/{group_gauge_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

group_gauge_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

CurrentWeightByGroupGaugeID returns the current weight since the the last epoch given a group gauge ID

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/current_weight_by_group_gauge_id/{group_gauge_id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/current_weight_by_group_gauge_id/{group_gauge_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/current_weight_by_group_gauge_id/{group_gauge_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/current_weight_by_group_gauge_id/{group_gauge_id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/current_weight_by_group_gauge_id/{group_gauge_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/current_weight_by_group_gauge_id/{group_gauge_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/current_weight_by_group_gauge_id/{group_gauge_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/current_weight_by_group_gauge_id/{group_gauge_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/current_weight_by_group_gauge_id/{group_gauge_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "gauge_weight": [
    {
      "gauge_id": "string",
      "weight_ratio": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GaugeByID returns gauges by their respective ID

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauge_by_id/{id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

idstring<uint64>requiredpath

Gague ID being queried

Response

200OK

A successful response.

default

An unexpected error response.

GaugeByID returns gauges by their respective ID

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauge_by_id/{id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauge_by_id/{id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauge_by_id/{id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauge_by_id/{id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauge_by_id/{id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauge_by_id/{id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauge_by_id/{id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauge_by_id/{id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauge_by_id/{id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "gauge": {
    "id": "string",
    "is_perpetual": true,
    "distribute_to": {
      "lock_query_type": "ByDuration",
      "denom": "string",
      "duration": "string",
      "timestamp": "2024-01-15T09:30:00Z"
    },
    "coins": [
      {
        "denom": "string",
        "amount": "string"
      }
    ],
    "start_time": "2024-01-15T09:30:00Z",
    "num_epochs_paid_over": "string",
    "filled_epochs": "string",
    "distributed_coins": [
      {
        "denom": "string",
        "amount": "string"
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Gauges returns both upcoming and active gauges

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauges

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalbooleanquery

pagination.reversebooleanquery

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response.

Gauges returns both upcoming and active gauges

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauges'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauges', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauges')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauges')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauges', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauges";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauges', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauges')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/gauges')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "data": [
    {
      "id": "string",
      "is_perpetual": true,
      "distribute_to": {
        "lock_query_type": "ByDuration",
        "denom": "string",
        "duration": "string",
        "timestamp": "2024-01-15T09:30:00Z"
      },
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "start_time": "2024-01-15T09:30:00Z",
      "num_epochs_paid_over": "string",
      "filled_epochs": "string",
      "distributed_coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GroupByGroupGaugeID returns a group given its group gauge ID

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/group_by_group_gauge_id/{id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

GroupByGroupGaugeID returns a group given its group gauge ID

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/group_by_group_gauge_id/{id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/group_by_group_gauge_id/{id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/group_by_group_gauge_id/{id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/group_by_group_gauge_id/{id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/group_by_group_gauge_id/{id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/group_by_group_gauge_id/{id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/group_by_group_gauge_id/{id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/group_by_group_gauge_id/{id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/group_by_group_gauge_id/{id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "group": {
    "group_gauge_id": "string",
    "internal_gauge_info": {
      "total_weight": "string",
      "gauge_records": [
        {
          "gauge_id": "string",
          "current_weight": "string",
          "cumulative_weight": "string"
        }
      ]
    },
    "splitting_policy": "ByVolume"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

LockableDurations returns lockable durations that are valid to distribute incentives for

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/lockable_durations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

LockableDurations returns lockable durations that are valid to distribute incentives for

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/lockable_durations'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/lockable_durations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/lockable_durations')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/lockable_durations')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/lockable_durations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/lockable_durations";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/lockable_durations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/lockable_durations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/lockable_durations')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "lockable_durations": [
    "string"
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ModuleToDistributeCoins returns coins that are going to be distributed

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/module_to_distribute_coins

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

ModuleToDistributeCoins returns coins that are going to be distributed

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/module_to_distribute_coins'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/module_to_distribute_coins', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/module_to_distribute_coins')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/module_to_distribute_coins')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/module_to_distribute_coins', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/module_to_distribute_coins";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/module_to_distribute_coins', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/module_to_distribute_coins')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/module_to_distribute_coins')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

RewardsEst returns an estimate of the rewards from now until a specified time in the future The querier either provides an address or a set of locks for which they want to find the associated rewards

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/rewards_est/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

Address that is being queried for future estimated rewards

lock_idsArray<string>query

Lock IDs included in future reward estimation.

end_epochstring<int64>query

Upper time limit of reward estimation Lower limit is current epoch.

Response

200OK

A successful response.

default

An unexpected error response.

RewardsEst returns an estimate of the rewards from now until a specified time in the future The querier either provides an address or a set of locks for which they want to find the associated rewards

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/rewards_est/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/rewards_est/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/rewards_est/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/rewards_est/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/rewards_est/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/rewards_est/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/rewards_est/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/rewards_est/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/rewards_est/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns scheduled gauges that have not yet occured

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalbooleanquery

pagination.reversebooleanquery

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response.

Returns scheduled gauges that have not yet occured

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "data": [
    {
      "id": "string",
      "is_perpetual": true,
      "distribute_to": {
        "lock_query_type": "ByDuration",
        "denom": "string",
        "duration": "string",
        "timestamp": "2024-01-15T09:30:00Z"
      },
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "start_time": "2024-01-15T09:30:00Z",
      "num_epochs_paid_over": "string",
      "filled_epochs": "string",
      "distributed_coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

UpcomingGaugesPerDenom returns scheduled gauges that have not yet occured by denom

GET

https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges_per_denom

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringquery

Filter for upcoming gagues that match specific denom.

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalbooleanquery

pagination.reversebooleanquery

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response.

UpcomingGaugesPerDenom returns scheduled gauges that have not yet occured by denom

curl -X GET 'https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges_per_denom'

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges_per_denom', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges_per_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges_per_denom')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges_per_denom', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges_per_denom";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges_per_denom', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges_per_denom')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/incentives/v1beta1/upcoming_gauges_per_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "upcoming_gauges": [
    {
      "id": "string",
      "is_perpetual": true,
      "distribute_to": {
        "lock_query_type": "ByDuration",
        "denom": "string",
        "duration": "string",
        "timestamp": "2024-01-15T09:30:00Z"
      },
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "start_time": "2024-01-15T09:30:00Z",
      "num_epochs_paid_over": "string",
      "filled_epochs": "string",
      "distributed_coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ]
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Lockup

Return a locked coins that can't be withdrawn

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_coins/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Return a locked coins that can't be withdrawn

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_coins/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_coins/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_coins/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_coins/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_coins/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_coins/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_coins/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_coins/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_coins/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns account locked records with a specific duration

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_duration/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

durationstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns account locked records with a specific duration

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_duration/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_duration/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_duration/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_duration/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_duration/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_duration/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_duration/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_duration/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_duration/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "locks": [
    {
      "ID": "string",
      "owner": "string",
      "duration": "string",
      "end_time": "2024-01-15T09:30:00Z",
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "reward_receiver_address": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns account locked records with longer duration

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

durationstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns account locked records with longer duration

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "locks": [
    {
      "ID": "string",
      "owner": "string",
      "duration": "string",
      "end_time": "2024-01-15T09:30:00Z",
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "reward_receiver_address": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns account's locked records for a denom with longer duration

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_denom/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

durationstringquery

denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns account's locked records for a denom with longer duration

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_denom/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_denom/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_denom/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_denom/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_denom/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_denom/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_denom/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_denom/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_denom/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "locks": [
    {
      "ID": "string",
      "owner": "string",
      "duration": "string",
      "end_time": "2024-01-15T09:30:00Z",
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "reward_receiver_address": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns account locked records with longer duration excluding tokens started unlocking

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_not_unlocking_only/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

durationstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns account locked records with longer duration excluding tokens started unlocking

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_not_unlocking_only/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_not_unlocking_only/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_not_unlocking_only/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_not_unlocking_only/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_not_unlocking_only/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_not_unlocking_only/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_not_unlocking_only/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_not_unlocking_only/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_longer_duration_not_unlocking_only/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "locks": [
    {
      "ID": "string",
      "owner": "string",
      "duration": "string",
      "end_time": "2024-01-15T09:30:00Z",
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "reward_receiver_address": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns locked records of an account with unlock time beyond timestamp

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

timestampstring<date-time>query

Response

200OK

A successful response.

default

An unexpected error response.

Returns locked records of an account with unlock time beyond timestamp

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "locks": [
    {
      "ID": "string",
      "owner": "string",
      "duration": "string",
      "end_time": "2024-01-15T09:30:00Z",
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "reward_receiver_address": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns lock records by address, timestamp, denom

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_denom/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

timestampstring<date-time>query

denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns lock records by address, timestamp, denom

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_denom/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_denom/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_denom/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_denom/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_denom/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_denom/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_denom/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_denom/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_denom/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "locks": [
    {
      "ID": "string",
      "owner": "string",
      "duration": "string",
      "end_time": "2024-01-15T09:30:00Z",
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "reward_receiver_address": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns locked records of an account with unlock time beyond timestamp excluding tokens started unlocking

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_not_unlocking_only/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

timestampstring<date-time>query

Response

200OK

A successful response.

default

An unexpected error response.

Returns locked records of an account with unlock time beyond timestamp excluding tokens started unlocking

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_not_unlocking_only/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_not_unlocking_only/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_not_unlocking_only/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_not_unlocking_only/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_not_unlocking_only/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_not_unlocking_only/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_not_unlocking_only/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_not_unlocking_only/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_locked_pasttime_not_unlocking_only/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "locks": [
    {
      "ID": "string",
      "owner": "string",
      "duration": "string",
      "end_time": "2024-01-15T09:30:00Z",
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "reward_receiver_address": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns unlockable coins which are not withdrawn yet

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlockable_coins/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns unlockable coins which are not withdrawn yet

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlockable_coins/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlockable_coins/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlockable_coins/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlockable_coins/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlockable_coins/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlockable_coins/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlockable_coins/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlockable_coins/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlockable_coins/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns unlocked records with unlock time before timestamp

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocked_before_time/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

timestampstring<date-time>query

Response

200OK

A successful response.

default

An unexpected error response.

Returns unlocked records with unlock time before timestamp

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocked_before_time/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocked_before_time/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocked_before_time/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocked_before_time/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocked_before_time/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocked_before_time/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocked_before_time/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocked_before_time/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocked_before_time/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "locks": [
    {
      "ID": "string",
      "owner": "string",
      "duration": "string",
      "end_time": "2024-01-15T09:30:00Z",
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "reward_receiver_address": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns unlocking coins

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocking_coins/{owner}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ownerstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns unlocking coins

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocking_coins/{owner}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocking_coins/{owner}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocking_coins/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocking_coins/{owner}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocking_coins/{owner}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocking_coins/{owner}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocking_coins/{owner}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocking_coins/{owner}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/account_unlocking_coins/{owner}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns lock record by id

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/lock_reward_receiver/{lock_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

lock_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns lock record by id

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/lock_reward_receiver/{lock_id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/lock_reward_receiver/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/lock_reward_receiver/{lock_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/lock_reward_receiver/{lock_id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/lock_reward_receiver/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/lock_reward_receiver/{lock_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/lock_reward_receiver/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/lock_reward_receiver/{lock_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/lock_reward_receiver/{lock_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "reward_receiver": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns lock record by id

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_by_id/{lock_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

lock_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns lock record by id

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_by_id/{lock_id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_by_id/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_by_id/{lock_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_by_id/{lock_id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_by_id/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_by_id/{lock_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_by_id/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_by_id/{lock_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_by_id/{lock_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "lock": {
    "ID": "string",
    "owner": "string",
    "duration": "string",
    "end_time": "2024-01-15T09:30:00Z",
    "coins": [
      {
        "denom": "string",
        "amount": "string"
      }
    ],
    "reward_receiver_address": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns total locked per denom with longer past given time

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_denom

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringquery

durationstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns total locked per denom with longer past given time

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_denom'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_denom', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_denom')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_denom', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_denom";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_denom', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_denom')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/locked_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "amount": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Return full balance of the module

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_balance

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Return full balance of the module

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_balance'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_balance', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_balance')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_balance')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_balance', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_balance";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_balance', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_balance')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_balance')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Return locked balance of the module

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_locked_amount

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Return locked balance of the module

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_locked_amount'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_locked_amount', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_locked_amount')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_locked_amount')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_locked_amount', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_locked_amount";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_locked_amount', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_locked_amount')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/module_locked_amount')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns next lock ID

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/next_lock_id

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Returns next lock ID

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/next_lock_id'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/next_lock_id', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/next_lock_id')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/next_lock_id')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/next_lock_id', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/next_lock_id";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/next_lock_id', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/next_lock_id')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/next_lock_id')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "lock_id": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params returns lockup params.

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Params returns lockup params.

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/params'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/params')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/params";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "params": {
    "force_unlock_allowed_addresses": [
      "string"
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns synthetic lockup by native lockup id

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

lock_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns synthetic lockup by native lockup id

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "synthetic_lock": {
    "underlying_lock_id": "string",
    "synth_denom": "string",
    "end_time": "2024-01-15T09:30:00Z",
    "duration": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns synthetic lockup by native lockup id Deprecated: use SyntheticLockupByLockupID instead

GET

https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

lock_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns synthetic lockup by native lockup id Deprecated: use SyntheticLockupByLockupID instead

curl -X GET 'https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "synthetic_locks": [
    {
      "underlying_lock_id": "string",
      "synth_denom": "string",
      "end_time": "2024-01-15T09:30:00Z",
      "duration": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Mint

EpochProvisions returns the current minting epoch provisions value.

GET

https://osmo.nownodes.io/osmosis/mint/v1beta1/epoch_provisions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

EpochProvisions returns the current minting epoch provisions value.

curl -X GET 'https://osmo.nownodes.io/osmosis/mint/v1beta1/epoch_provisions'

const response = await fetch('https://osmo.nownodes.io/osmosis/mint/v1beta1/epoch_provisions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/mint/v1beta1/epoch_provisions')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/mint/v1beta1/epoch_provisions')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/mint/v1beta1/epoch_provisions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/mint/v1beta1/epoch_provisions";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/mint/v1beta1/epoch_provisions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/mint/v1beta1/epoch_provisions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/mint/v1beta1/epoch_provisions')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "epoch_provisions": "dGVzdA=="
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params returns the total set of minting parameters.

GET

https://osmo.nownodes.io/osmosis/mint/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Params returns the total set of minting parameters.

curl -X GET 'https://osmo.nownodes.io/osmosis/mint/v1beta1/params'

const response = await fetch('https://osmo.nownodes.io/osmosis/mint/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/mint/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/mint/v1beta1/params')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/mint/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/mint/v1beta1/params";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/mint/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/mint/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/mint/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "params": {
    "mint_denom": "string",
    "genesis_epoch_provisions": "string",
    "epoch_identifier": "string",
    "reduction_period_in_epochs": "string",
    "reduction_factor": "string",
    "distribution_proportions": {
      "staking": "string",
      "pool_incentives": "string",
      "developer_rewards": "string",
      "community_pool": "string"
    },
    "weighted_developer_rewards_receivers": [
      {
        "address": "string",
        "weight": "string"
      }
    ],
    "minting_rewards_distribution_start_epoch": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Pool-Incentives

DistrInfo returns the pool's matching gauge ids and weights.

GET

https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/distr_info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

DistrInfo returns the pool's matching gauge ids and weights.

curl -X GET 'https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/distr_info'

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/distr_info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/distr_info')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/distr_info')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/distr_info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/distr_info";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/distr_info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/distr_info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/distr_info')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "distr_info": {
    "total_weight": "string",
    "records": [
      {
        "gauge_id": "string",
        "weight": "string"
      }
    ]
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

ExternalIncentiveGauges returns external incentive gauges.

GET

https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/external_incentive_gauges

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

ExternalIncentiveGauges returns external incentive gauges.

curl -X GET 'https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/external_incentive_gauges'

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/external_incentive_gauges', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/external_incentive_gauges')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/external_incentive_gauges')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/external_incentive_gauges', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/external_incentive_gauges";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/external_incentive_gauges', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/external_incentive_gauges')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/external_incentive_gauges')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "data": [
    {
      "id": "string",
      "is_perpetual": true,
      "distribute_to": {
        "lock_query_type": "ByDuration",
        "denom": "string",
        "duration": "string",
        "timestamp": "2024-01-15T09:30:00Z"
      },
      "coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ],
      "start_time": "2024-01-15T09:30:00Z",
      "num_epochs_paid_over": "string",
      "filled_epochs": "string",
      "distributed_coins": [
        {
          "denom": "string",
          "amount": "string"
        }
      ]
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GaugeIds takes the pool id and returns the matching gauge ids and durations

GET

https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/gauge-ids/{pool_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pool_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

GaugeIds takes the pool id and returns the matching gauge ids and durations

curl -X GET 'https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/gauge-ids/{pool_id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/gauge-ids/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/gauge-ids/{pool_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/gauge-ids/{pool_id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/gauge-ids/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/gauge-ids/{pool_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/gauge-ids/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/gauge-ids/{pool_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/gauge-ids/{pool_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "gauge_ids_with_duration": [
    {
      "gauge_id": "string",
      "duration": "string",
      "gauge_incentive_percentage": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

IncentivizedPools returns currently incentivized pools

GET

https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/incentivized_pools

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

IncentivizedPools returns currently incentivized pools

curl -X GET 'https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/incentivized_pools'

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/incentivized_pools', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/incentivized_pools')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/incentivized_pools')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/incentivized_pools', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/incentivized_pools";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/incentivized_pools', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/incentivized_pools')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/incentivized_pools')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "incentivized_pools": [
    {
      "pool_id": "string",
      "lockable_duration": "string",
      "gauge_id": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

LockableDurations returns lock durations for pools.

GET

https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/lockable_durations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

LockableDurations returns lock durations for pools.

curl -X GET 'https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/lockable_durations'

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/lockable_durations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/lockable_durations')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/lockable_durations')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/lockable_durations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/lockable_durations";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/lockable_durations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/lockable_durations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/lockable_durations')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "lockable_durations": [
    "string"
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params returns pool incentives params.

GET

https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Params returns pool incentives params.

curl -X GET 'https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/params'

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/params')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/params";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/pool-incentives/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "params": {
    "minted_denom": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Superfluid

Returns all of a user's full range CL positions that are superfluid staked.

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_delegated_cl_positions/{delegator_address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addressstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns all of a user's full range CL positions that are superfluid staked.

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_delegated_cl_positions/{delegator_address}'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_delegated_cl_positions/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_delegated_cl_positions/{delegator_address}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_delegated_cl_positions/{delegator_address}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_delegated_cl_positions/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_delegated_cl_positions/{delegator_address}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_delegated_cl_positions/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_delegated_cl_positions/{delegator_address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_delegated_cl_positions/{delegator_address}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "cl_pool_user_position_records": [
    {
      "validator_address": "string",
      "position_id": "string",
      "lock_id": "string",
      "synthetic_lock": {
        "underlying_lock_id": "string",
        "synth_denom": "string",
        "end_time": "2024-01-15T09:30:00Z",
        "duration": "string"
      },
      "delegation_amount": {
        "denom": "string",
        "amount": "string"
      },
      "equivalent_staked_amount": {
        "denom": "string",
        "amount": "string"
      }
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addressstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

GET /osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/account_undelegating_cl_positions/{delegator_address}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "cl_pool_user_position_records": [
    {
      "validator_address": "string",
      "position_id": "string",
      "lock_id": "string",
      "synthetic_lock": {
        "underlying_lock_id": "string",
        "synth_denom": "string",
        "end_time": "2024-01-15T09:30:00Z",
        "duration": "string"
      },
      "delegation_amount": {
        "denom": "string",
        "amount": "string"
      },
      "equivalent_staked_amount": {
        "denom": "string",
        "amount": "string"
      }
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns all registered superfluid assets.

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_assets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Returns all registered superfluid assets.

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_assets'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_assets', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_assets')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_assets')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_assets', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_assets";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_assets', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_assets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_assets')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "assets": [
    {
      "denom": "string",
      "asset_type": "SuperfluidAssetTypeNative"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns all superfluid intermediary accounts.

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_intermediary_accounts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

pagination.keystring<byte>query

key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set.

pagination.offsetstring<uint64>query

offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set.

pagination.limitstring<uint64>query

limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app.

pagination.count_totalbooleanquery

pagination.reversebooleanquery

reverse is set to true if results are to be returned in the descending order.

Since: cosmos-sdk 0.43

Response

200OK

A successful response.

default

An unexpected error response.

Returns all superfluid intermediary accounts.

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_intermediary_accounts'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_intermediary_accounts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_intermediary_accounts')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_intermediary_accounts')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_intermediary_accounts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_intermediary_accounts";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_intermediary_accounts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_intermediary_accounts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_intermediary_accounts')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "accounts": [
    {
      "denom": "string",
      "val_addr": "string",
      "gauge_id": "string",
      "address": "string"
    }
  ],
  "pagination": {
    "next_key": "dGVzdA==",
    "total": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns the total amount of osmo superfluidly staked. Response is denominated in uosmo.

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_superfluid_delegations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Returns the total amount of osmo superfluidly staked. Response is denominated in uosmo.

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_superfluid_delegations'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_superfluid_delegations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_superfluid_delegations')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_superfluid_delegations')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_superfluid_delegations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_superfluid_delegations";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_superfluid_delegations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_superfluid_delegations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/all_superfluid_delegations')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "total_delegations": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns the osmo equivalent multiplier used in the most recent epoch.

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_multiplier

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns the osmo equivalent multiplier used in the most recent epoch.

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_multiplier'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_multiplier', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_multiplier')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_multiplier')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_multiplier', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_multiplier";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_multiplier', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_multiplier')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_multiplier')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "osmo_equivalent_multiplier": {
    "epoch_number": "string",
    "denom": "string",
    "multiplier": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns superfluid asset type, whether if it's a native asset or an lp share.

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_type

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns superfluid asset type, whether if it's a native asset or an lp share.

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_type'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_type', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_type')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_type')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_type', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_type";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_type', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_type')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/asset_type')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "asset_type": "SuperfluidAssetTypeNative"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns intermediary account connected to a superfluid staked lock by id

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/connected_intermediary_account/{lock_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

lock_idstring<uint64>requiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns intermediary account connected to a superfluid staked lock by id

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/connected_intermediary_account/{lock_id}'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/connected_intermediary_account/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/connected_intermediary_account/{lock_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/connected_intermediary_account/{lock_id}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/connected_intermediary_account/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/connected_intermediary_account/{lock_id}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/connected_intermediary_account/{lock_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/connected_intermediary_account/{lock_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/connected_intermediary_account/{lock_id}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "account": {
    "denom": "string",
    "val_addr": "string",
    "gauge_id": "string",
    "address": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns the amount of a specific denom delegated to a specific validator This is labeled an estimate, because the way it calculates the amount can lead rounding errors from the true delegated amount

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/estimate_superfluid_delegation_amount_by_validator_denom

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validator_addressstringquery

denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns the amount of a specific denom delegated to a specific validator This is labeled an estimate, because the way it calculates the amount can lead rounding errors from the true delegated amount

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/estimate_superfluid_delegation_amount_by_validator_denom'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/estimate_superfluid_delegation_amount_by_validator_denom', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/estimate_superfluid_delegation_amount_by_validator_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/estimate_superfluid_delegation_amount_by_validator_denom')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/estimate_superfluid_delegation_amount_by_validator_denom', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/estimate_superfluid_delegation_amount_by_validator_denom";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/estimate_superfluid_delegation_amount_by_validator_denom', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/estimate_superfluid_delegation_amount_by_validator_denom')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/estimate_superfluid_delegation_amount_by_validator_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "total_delegated_coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params returns the total set of superfluid parameters.

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Params returns the total set of superfluid parameters.

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/params'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/params')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/params";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "params": {
    "minimum_risk_factor": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns the coins superfluid delegated for the delegator, validator, denom triplet

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegation_amount

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addressstringquery

validator_addressstringquery

denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns the coins superfluid delegated for the delegator, validator, denom triplet

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegation_amount'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegation_amount', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegation_amount')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegation_amount')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegation_amount', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegation_amount";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegation_amount', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegation_amount')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegation_amount')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "amount": [
    {
      "denom": "string",
      "amount": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns all the delegated superfluid poistions for a specific delegator.

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations/{delegator_address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addressstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns all the delegated superfluid poistions for a specific delegator.

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations/{delegator_address}'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations/{delegator_address}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations/{delegator_address}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations/{delegator_address}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations/{delegator_address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations/{delegator_address}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "superfluid_delegation_records": [
    {
      "delegator_address": "string",
      "validator_address": "string",
      "delegation_amount": {
        "denom": "string",
        "amount": "string"
      },
      "equivalent_staked_amount": {
        "denom": "string",
        "amount": "string"
      }
    }
  ],
  "total_delegated_coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ],
  "total_equivalent_staked_amount": {
    "denom": "string",
    "amount": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns all the superfluid positions of a specific denom delegated to one validator

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations_by_validator_denom

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

validator_addressstringquery

denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns all the superfluid positions of a specific denom delegated to one validator

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations_by_validator_denom'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations_by_validator_denom', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations_by_validator_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations_by_validator_denom')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations_by_validator_denom', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations_by_validator_denom";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations_by_validator_denom', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations_by_validator_denom')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_delegations_by_validator_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "superfluid_delegation_records": [
    {
      "delegator_address": "string",
      "validator_address": "string",
      "delegation_amount": {
        "denom": "string",
        "amount": "string"
      },
      "equivalent_staked_amount": {
        "denom": "string",
        "amount": "string"
      }
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns all the undelegating superfluid poistions for a specific delegator.

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_undelegations_by_delegator/{delegator_address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addressstringrequiredpath

denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

Returns all the undelegating superfluid poistions for a specific delegator.

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_undelegations_by_delegator/{delegator_address}'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_undelegations_by_delegator/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_undelegations_by_delegator/{delegator_address}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_undelegations_by_delegator/{delegator_address}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_undelegations_by_delegator/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_undelegations_by_delegator/{delegator_address}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_undelegations_by_delegator/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_undelegations_by_delegator/{delegator_address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/superfluid_undelegations_by_delegator/{delegator_address}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "superfluid_delegation_records": [
    {
      "delegator_address": "string",
      "validator_address": "string",
      "delegation_amount": {
        "denom": "string",
        "amount": "string"
      },
      "equivalent_staked_amount": {
        "denom": "string",
        "amount": "string"
      }
    }
  ],
  "total_undelegated_coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ],
  "synthetic_locks": [
    {
      "underlying_lock_id": "string",
      "synth_denom": "string",
      "end_time": "2024-01-15T09:30:00Z",
      "duration": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/supply

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

GET /osmosis/superfluid/v1beta1/supply

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/supply'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/supply', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/supply')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/supply')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/supply', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/supply";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/supply', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/supply')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/supply')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "amount": {
    "denom": "string",
    "amount": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns the specified delegations for a specific delegator

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/total_delegation_by_delegator/{delegator_address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

delegator_addressstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns the specified delegations for a specific delegator

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/total_delegation_by_delegator/{delegator_address}'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/total_delegation_by_delegator/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/total_delegation_by_delegator/{delegator_address}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/total_delegation_by_delegator/{delegator_address}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/total_delegation_by_delegator/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/total_delegation_by_delegator/{delegator_address}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/total_delegation_by_delegator/{delegator_address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/total_delegation_by_delegator/{delegator_address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/total_delegation_by_delegator/{delegator_address}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "superfluid_delegation_records": [
    {
      "delegator_address": "string",
      "validator_address": "string",
      "delegation_amount": {
        "denom": "string",
        "amount": "string"
      },
      "equivalent_staked_amount": {
        "denom": "string",
        "amount": "string"
      }
    }
  ],
  "delegation_response": [
    {
      "delegation": {
        "delegator_address": "string",
        "validator_address": "string",
        "shares": "string"
      },
      "balance": {
        "denom": "string",
        "amount": "string"
      }
    }
  ],
  "total_delegated_coins": [
    {
      "denom": "string",
      "amount": "string"
    }
  ],
  "total_equivalent_staked_amount": {
    "denom": "string",
    "amount": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns a list of whitelisted pool ids to unpool.

GET

https://osmo.nownodes.io/osmosis/superfluid/v1beta1/unpool_whitelist

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Returns a list of whitelisted pool ids to unpool.

curl -X GET 'https://osmo.nownodes.io/osmosis/superfluid/v1beta1/unpool_whitelist'

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/unpool_whitelist', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/unpool_whitelist')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/unpool_whitelist')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/unpool_whitelist', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/superfluid/v1beta1/unpool_whitelist";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/unpool_whitelist', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/unpool_whitelist')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/superfluid/v1beta1/unpool_whitelist')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "pool_ids": [
    "string"
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

TokenFactory

DenomAuthorityMetadata defines a gRPC query method for fetching DenomAuthorityMetadata for a particular denom.

GET

https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

DenomAuthorityMetadata defines a gRPC query method for fetching DenomAuthorityMetadata for a particular denom.

curl -X GET 'https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata'

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "authority_metadata": {
    "admin": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

BeforeSendHookAddress defines a gRPC query method for getting the address registered for the before send hook.

GET

https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/before_send_hook

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

BeforeSendHookAddress defines a gRPC query method for getting the address registered for the before send hook.

curl -X GET 'https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/before_send_hook'

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/before_send_hook', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/before_send_hook')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/before_send_hook')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/before_send_hook', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/before_send_hook";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/before_send_hook', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/before_send_hook')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms/{denom}/before_send_hook')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "cosmwasm_address": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DenomsFromCreator defines a gRPC query method for fetching all denominations created by a specific admin/creator.

GET

https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

creatorstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

DenomsFromCreator defines a gRPC query method for fetching all denominations created by a specific admin/creator.

curl -X GET 'https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}'

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "denoms": [
    "string"
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Params defines a gRPC query method that returns the tokenfactory module's parameters.

GET

https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Params defines a gRPC query method that returns the tokenfactory module's parameters.

curl -X GET 'https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/params'

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/params')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/params";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/tokenfactory/v1beta1/params')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "params": {
    "denom_creation_fee": [
      {
        "denom": "string",
        "amount": "string"
      }
    ],
    "denom_creation_gas_consume": "string"
  }
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

TxFees

Returns a list of all base denom tokens and their corresponding pools.

GET

https://osmo.nownodes.io/osmosis/txfees/v1beta1/base_denom

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Returns a list of all base denom tokens and their corresponding pools.

curl -X GET 'https://osmo.nownodes.io/osmosis/txfees/v1beta1/base_denom'

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/base_denom', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/txfees/v1beta1/base_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/txfees/v1beta1/base_denom')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/base_denom', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/txfees/v1beta1/base_denom";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/base_denom', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/txfees/v1beta1/base_denom')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/txfees/v1beta1/base_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "base_denom": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns a list of all base denom tokens and their corresponding pools.

GET

https://osmo.nownodes.io/osmosis/txfees/v1beta1/cur_eip_base_fee

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

Returns a list of all base denom tokens and their corresponding pools.

curl -X GET 'https://osmo.nownodes.io/osmosis/txfees/v1beta1/cur_eip_base_fee'

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/cur_eip_base_fee', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/txfees/v1beta1/cur_eip_base_fee')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/txfees/v1beta1/cur_eip_base_fee')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/cur_eip_base_fee', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/txfees/v1beta1/cur_eip_base_fee";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/cur_eip_base_fee', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/txfees/v1beta1/cur_eip_base_fee')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/txfees/v1beta1/cur_eip_base_fee')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "base_fee": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Returns the poolID for a specified denom input.

GET

https://osmo.nownodes.io/osmosis/txfees/v1beta1/denom_pool_id/{denom}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringrequiredpath

Response

200OK

A successful response.

default

An unexpected error response.

Returns the poolID for a specified denom input.

curl -X GET 'https://osmo.nownodes.io/osmosis/txfees/v1beta1/denom_pool_id/{denom}'

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/denom_pool_id/{denom}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/txfees/v1beta1/denom_pool_id/{denom}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/txfees/v1beta1/denom_pool_id/{denom}')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/denom_pool_id/{denom}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/txfees/v1beta1/denom_pool_id/{denom}";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/denom_pool_id/{denom}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/txfees/v1beta1/denom_pool_id/{denom}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/txfees/v1beta1/denom_pool_id/{denom}')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "poolID": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

FeeTokens returns a list of all the whitelisted fee tokens and their corresponding pools. It does not include the BaseDenom, which has its own query endpoint

GET

https://osmo.nownodes.io/osmosis/txfees/v1beta1/fee_tokens

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

A successful response.

default

An unexpected error response.

FeeTokens returns a list of all the whitelisted fee tokens and their corresponding pools. It does not include the BaseDenom, which has its own query endpoint

curl -X GET 'https://osmo.nownodes.io/osmosis/txfees/v1beta1/fee_tokens'

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/fee_tokens', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/txfees/v1beta1/fee_tokens')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/txfees/v1beta1/fee_tokens')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/fee_tokens', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/txfees/v1beta1/fee_tokens";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/fee_tokens', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/txfees/v1beta1/fee_tokens')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/txfees/v1beta1/fee_tokens')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "fee_tokens": [
    {
      "denom": "string",
      "poolID": "string"
    }
  ]
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

DenomSpotPrice returns all spot prices by each registered token denom.

GET

https://osmo.nownodes.io/osmosis/txfees/v1beta1/spot_price_by_denom

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

denomstringquery

Response

200OK

A successful response.

default

An unexpected error response.

DenomSpotPrice returns all spot prices by each registered token denom.

curl -X GET 'https://osmo.nownodes.io/osmosis/txfees/v1beta1/spot_price_by_denom'

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/spot_price_by_denom', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/txfees/v1beta1/spot_price_by_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/txfees/v1beta1/spot_price_by_denom')
data = response.json()

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/spot_price_by_denom', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://osmo.nownodes.io/osmosis/txfees/v1beta1/spot_price_by_denom";
const apiKey = "YOUR_API_KEY";

async function nownodesRequest(payload) {
  const response = await fetch(endpoint, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "api-key": apiKey,
    },
    body: JSON.stringify(payload),
  });

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://osmo.nownodes.io/osmosis/txfees/v1beta1/spot_price_by_denom', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://osmo.nownodes.io/osmosis/txfees/v1beta1/spot_price_by_denom')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://osmo.nownodes.io/osmosis/txfees/v1beta1/spot_price_by_denom')
request = Net::HTTP::Get.new(uri)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
data = JSON.parse(response.body)

{
  "poolID": "string",
  "spot_price": "string"
}

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "dGVzdA=="
    }
  ]
}

Documentation

How to migrate to NOWNodes

Authentication

API Reference

Epochs

Authorizations

Parameters

Response

Authorizations

Response

Gamm

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Incentives

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters