Ebisu's Bay API — Developer Reference

The Ebisu's Bay API gives developers direct access to the marketplace on Cronos: browse listings, collections, wallet holdings, and market-wide stats over plain REST — and fill marketplace orders on-chain through the gasless-listing validator. No SDK required.

Getting Started

Base URL: https://api.ebisusbay.com

All browse endpoints are plain HTTPS GETs that return JSON. No authentication is required. CORS is open (Access-Control-Allow-Origin: *) and strong ETags are emitted, so conditional GETs (If-None-Match) work.

Optional API key. If you have a registered partner key you may send it in the eb-api-key header (the x-api-key header name is also accepted). Today the key's only effect is rate-limit tiering: recognized keys are effectively exempt from the app-side courtesy limiter (unauthenticated traffic is capped at 250 requests / 5 minutes per IP-or-key; the API advertises this via standard RateLimit-* headers). The key never changes response contents. App-side limiting is being phased out in favor of proxy-level throttling — requests may be throttled at the edge; handle 429/503 with backoff regardless of whether you send a key.

Pagination. All list endpoints are page/pageSize paginated and cap pageSize at 100. Requesting pageSize > 100 adds an advisory response header X-PageSize-Warning: pageSize will be capped at 100 in a future release.

Freshness. Aggregate endpoints (/collections, /marketdata, collection stats) are served from short server-side caches (roughly 30–60 s; /marketdata's underlying aggregate is rematerialized about every 5 minutes). Treat figures as near-real-time, not tick-exact.

Chain scope. The marketplace data is Cronos mainnet (chain = 25, name cronos). Chain ids 1 / 338 / 282 / 388 are accepted by validation for legacy compatibility, but only chain 25 returns listing data.

Deprecated legacy endpoints

The following legacy paths are retired and answer HTTP 410 with the stable body {"status":410,"error":"DEPRECATED_ENDPOINT"}: GET /auctions, GET /farms, GET /farmbalance, GET /bundle, POST /bundle, GET /api/supply/circulating.

GET /wallets (v1) answers HTTP 301 with a JSON body directing callers to /v2/wallets (no Location header). GET /getLeaders remains as a decommissioned stub that always returns an empty result set.

GET /listings

GET https://api.ebisusbay.com/listings

Browse active (and historical) marketplace listings. This is the primary feed for integrators: it returns full listing rows — price, currency, seller, state, timestamps — joined with token metadata and collection info. By default it serves only presentable listings: not marked invalid, not expired (unless already sold/cancelled), and belonging to non-blacklisted collections. The listingId values returned here are exactly what the gasless validator accepts.

Request parameters

Example

# Active listings, newest first (default sort)
curl "https://api.ebisusbay.com/listings?state=0&pageSize=10"

# Filter by collection + price range, cheapest first
curl "https://api.ebisusbay.com/listings?state=0&collection=0x719fdfb0ba006747a83438cc8900c8a2b35e0aff&sortBy=price&direction=asc"

const res = await fetch(
  "https://api.ebisusbay.com/listings?state=0&pageSize=10"
);
const body = await res.json();

// Legacy quirk: an unknown parameter yields HTTP 400 while the body still
// carries a full result page — check for the `listings` key, not `res.ok`.
if (!Array.isArray(body.listings)) {
  throw new Error(body.error ?? "No listing data returned");
}

for (const listing of body.listings) {
  console.log(listing.listingId, listing.nft?.name, listing.price);
}

interface ListingsResponse {
  status: number;
  error?: string;
  page: number;
  totalCount: number;
  pageSize: number;
  totalPages: number;
  listings?: Listing[];
}

interface Listing {
  listingId: string; // decimal (legacy) or 0x… digest (gasless)
  nftId: string;
  nftAddress: string;
  chain: number;
  valid: boolean;
  amount: string;
  invalid: number;
  seller: string;
  purchaser: string | null;
  state: 0 | 1 | 2; // active / sold / cancelled
  price: string; // human-decimal string in `currency` units (NOT wei)
  currency: string; // 0x000…0 = native CRO
  royalty: string;
  fee: string;
  saleTime: string; // unix seconds as string; "0" when unsold
  listingTime: string;
  expirationDate: string | null;
  transactionHash: string | null;
  nft: { name?: string; image?: string; rank?: number } & Record<
    string,
    unknown
  >;
  collection: {
    address: string;
    name: string;
    slug: string;
    metadata: Record<string, unknown>;
  };
}

const res = await fetch(
  "https://api.ebisusbay.com/listings?state=0&pageSize=10"
);
const body = (await res.json()) as ListingsResponse;
if (!body.listings) throw new Error(body.error ?? "No listing data returned");

const listingIds = body.listings.map((l) => l.listingId);

Response

Envelope (key order as served):

Each listing object:

Real (live) example — GET /listings?state=0&pageSize=1 (nft/collection metadata trimmed; real responses carry the full attribute list and socials):

{
  "status": 200, "page": 1, "totalCount": 49738, "pageSize": 1, "totalPages": 49738,
  "listings": [{
    "listingId": "11", "nftId": "273",
    "nftAddress": "0xce5cac89e25dbccd590090994919a5ef53bbd6c0",
    "chain": 25, "valid": true, "amount": "1", "invalid": 1,
    "seller": "0x7ff3d5cc69766652495ab5c3323224cf6e2b3229",
    "purchaser": "0x0000000000000000000000000000000000000000",
    "state": 0, "price": "777",
    "currency": "0x0000000000000000000000000000000000000000",
    "royalty": "38.85", "fee": "23.31", "saleTime": "0",
    "listingTime": "1639048510", "expirationDate": null, "transactionHash": null,
    "nft": {
      "nftId": "273", "nftAddress": "0xce5cac89e25dbccd590090994919a5ef53bbd6c0", "chain": 25,
      "edition": 273, "name": "CronosEyez #273",
      "image": "https://ipfs.ebisusbay.com/ipfs/QmfAUP7PzD1s5qHiprZYD1ZsSgogMEGoSCdxT7qbsYvicQ/273.png",
      "rank": 146,
      "attributes": [{ "value": "dark ray", "trait_type": "Background" }]
    },
    "collection": {
      "address": "0xce5cac89e25dbccd590090994919a5ef53bbd6c0",
      "name": "CronosEyezNFT", "slug": "cronoseyez",
      "metadata": { "avatar": "https://cdn-prod.ebisusbay.com/files/collection-images/cronoseyez/gen1/avatar.jpg" }
    }
  }]
}

Errors

Caveats

• Unknown-parameter quirk: an unknown parameter yields HTTP 400 but the body still contains the full result page (verified live). Do not treat HTTP 400 as "no data" — check for the listings key.
• Free-text search and traits/powertraits filters are currently non-functional on this endpoint: they return a degraded {"status":200} body without listings. Numeric search (token id / rank) works. For trait filtering, use /fullcollections (optionally with listed=1 to keep only listed tokens).
• price is a human decimal string in the listing currency — multiply into wei yourself if you need on-chain units (the validator does this for you).
• Only chain 25 (Cronos) returns rows; chain=388 validates but yields totalCount: 0.
• An unknown chain name (e.g. chain=foo) is not rejected — it silently disables the chain filter (legacy quirk).
• Default feed excludes: listings with invalid > 1, expired-and-still-active listings, and collections outside blacklist codes {0, 1, 4}.
• Results may be up to ~60 s stale (server-side response caching on hot query shapes).
• Requests may be throttled at the edge; handle 429/503 with backoff.

GET /fullcollections

GET https://api.ebisusbay.com/fullcollections

Browse every token in a collection — listed and unlisted alike — with per-token market context (active listing, last sale, best offer) and full metadata. Where /listings is a feed of marketplace listings, /fullcollections is the token-first view of a collection, and it is the endpoint that supports trait filtering: pass a traits JSON object to narrow the collection to tokens carrying specific attribute values.

For snapshot-style integrations (allowlists, raffle rolls, bot checks) add idsOnly=1 and the endpoint answers with the complete matching token-id list in a single response — no paging.

Request parameters

Trait filtering

traits is a JSON object mapping trait categories to arrays of accepted values, URL-encoded into the query string:

• AND across categories, OR within a category — {"Background":["Pink","Blue"],"Fur":["Gold"]} matches tokens whose Background is Pink or Blue and whose Fur is Gold.
• Values match exactly (case-sensitive): "pink" does not match "Pink". Take values verbatim from the token metadata's attributes (trait_type / value pairs, as returned by this endpoint or by /nft).
• Numeric attribute values match whether the collection's metadata stored them as strings or numbers — pass them as strings ({"Level":["5"]}).
• Limits: at most 32 categories, 64 values per category, 256 characters per name/value — beyond that the request is rejected with a clean 400.
• Malformed traits JSON (or a non-string value item, e.g. [5] without quotes) → 500 (legacy behavior; fix the JSON).

Example — all token ids with a trait

# Complete id list for Background = Pink (one call, no paging)
curl -G "https://api.ebisusbay.com/fullcollections" \
  --data-urlencode "address=0x719fdfb0ba006747a83438cc8900c8a2b35e0aff" \
  --data-urlencode 'traits={"Background":["Pink"]}' \
  --data-urlencode "idsOnly=1"

# Same filter, full NFT objects, paginated
curl -G "https://api.ebisusbay.com/fullcollections" \
  --data-urlencode "address=0x719fdfb0ba006747a83438cc8900c8a2b35e0aff" \
  --data-urlencode 'traits={"Background":["Pink"]}' \
  --data-urlencode "pageSize=50"

const params = new URLSearchParams({
  address: "0x719fdfb0ba006747a83438cc8900c8a2b35e0aff",
  traits: JSON.stringify({ Background: ["Pink"] }),
  idsOnly: "1",
});
const res = await fetch(`https://api.ebisusbay.com/fullcollections?${params}`);
const body = await res.json();

if (!Array.isArray(body.tokenIds)) {
  throw new Error(body.error ?? "No token data returned");
}
console.log(`${body.totalCount} matching tokens:`, body.tokenIds);
// -> 4 matching tokens: ["5", "100", "200", "512"]

interface FullCollectionsIdsResponse {
  status: number;
  error?: string;
  totalCount: number;
  tokenIds: string[]; // numeric ascending
}

const params = new URLSearchParams({
  address: "0x719fdfb0ba006747a83438cc8900c8a2b35e0aff",
  traits: JSON.stringify({ Background: ["Pink"] }),
  idsOnly: "1",
});
const res = await fetch(`https://api.ebisusbay.com/fullcollections?${params}`);
const body = (await res.json()) as FullCollectionsIdsResponse;
if (!body.tokenIds) throw new Error(body.error ?? "No token data returned");

Response

With idsOnly=1:

Without idsOnly (default), the paginated envelope:

Each token object: id, address, chain, owner, then market (active listing: id, price, currency, seller, expirationDate, uri — empty object when unlisted), last_sale, offer (best open offer), followed by the token's metadata fields (name, image, description, rank, attributes, …).

{
  "status": 200, "page": 1, "totalCount": 4, "pageSize": 100, "totalPages": 1,
  "nfts": [{
    "id": "5",
    "address": "0x719fdfb0ba006747a83438cc8900c8a2b35e0aff",
    "chain": 25,
    "owner": "0x7ff3d5cc69766652495ab5c3323224cf6e2b3229",
    "market": { "uri": "https://app.ebisusbay.com/collection/cronos/0x719f…0aff/5" },
    "last_sale": {},
    "offer": {},
    "name": "Example #5",
    "image": "https://ipfs.ebisusbay.com/ipfs/Qm…/5.png",
    "rank": 146,
    "attributes": [{ "trait_type": "Background", "value": "Pink" }]
  }]
}

Errors

Caveats

• listed, currency and the price/listing-time bounds filter on the active listing, so combining them with idsOnly=1 returns only ids that currently satisfy them — a listing snapshot, not a permanent trait set.
• minPrice/maxPrice/minListingTime/maxListingTime silently drop tokens without an active listing (legacy semantics).
• Results may be up to ~60 s stale (server-side response caching); token-id sets for a fixed trait filter change rarely, so this is usually irrelevant.
• Requests may be throttled at the edge; handle 429/503 with backoff.

GET /collections — ranked list

GET https://api.ebisusbay.com/collections

Without an address/collection filter, returns the marketplace's collections ranked by real 30-day volume (descending) — the same ranking the Ebisu's Bay collections page uses — in a detailed per-collection shape: verification, holders/supply, all-time and windowed (1d/7d/30d) stats, metadata and blacklist status.

Request parameters (ranked mode)

Unlike most legacy endpoints, the ranked list rejects unknown parameters outright (HTTP 400, {"status":400,"error":"Invalid parameter specified"}, no data).

Example

# Top collections by 30-day volume
curl "https://api.ebisusbay.com/collections?page=1&pageSize=10"

const res = await fetch(
  "https://api.ebisusbay.com/collections?page=1&pageSize=10"
);
const body = await res.json();

// Ranked mode rejects unknown parameters outright (HTTP 400, no data),
// but a rare degraded 200 can omit `collections` — check the key.
if (!Array.isArray(body.collections)) {
  throw new Error(body.error ?? "No collection data returned");
}

for (const c of body.collections) {
  console.log(c.name, c.stats.total.volume30d, c.stats.total.floorPrice);
}

interface CollectionsResponse {
  status: number;
  error?: string;
  page: number;
  totalCount: number;
  pageSize: number;
  totalPages: number;
  collections?: Collection[];
}

interface Collection {
  chain: number;
  verification: {
    verified: boolean;
    doxx: boolean | string;
    kyc: boolean | string;
  };
  holders?: string; // ERC721 only — absent for ERC1155
  totalSupply?: string; // ERC721 only — absent for ERC1155
  address: string;
  owner?: string;
  ownerExt?: string | null;
  multiToken: boolean;
  is1155: boolean;
  name: string;
  slug: string;
  listable: boolean;
  // active/complete/sales/floorPrice/avgSalePrice/volume + 1d/7d/30d windows.
  // All CRO-denominated decimal strings; `*_increase` and `royalty` are
  // always "0" (kept for shape compatibility).
  stats: { total: Record<string, string> };
  metadata: Record<string, unknown>;
  blacklisted: number; // 0 = clean; 4 = unreviewed default
}

const res = await fetch("https://api.ebisusbay.com/collections?pageSize=10");
const body = (await res.json()) as CollectionsResponse;
if (!body.collections) throw new Error(body.error ?? "No collection data");

Response

Envelope: { status, page, totalCount, pageSize, totalPages, collections[] }.

Each collection object (key order as served):

Real (live) example — GET /collections?pageSize=2 (first item, trimmed):

{
  "status": 200, "page": 1, "totalCount": 1090, "pageSize": 2, "totalPages": 545,
  "collections": [{
    "chain": 25,
    "verification": { "verified": true, "doxx": "", "kyc": "" },
    "holders": "687", "totalSupply": "5211",
    "address": "0x719fdfb0ba006747a83438cc8900c8a2b35e0aff",
    "multiToken": false, "is1155": false,
    "name": "Wolfies", "slug": "wolfies", "listable": true,
    "stats": { "total": {
      "active": "350", "complete": "5475", "sales": "5475",
      "floorPrice": "1298.000000000000000000",
      "avgSalePrice": "940.272953194650817215",
      "volume": "5062429.58",
      "volume1d": "6785", "sales1d": "5",
      "volume7d": "39835", "sales7d": "21",
      "volume30d": "179598.32", "sales30d": "124",
      "avgSalePrice30d": "1448.373548387096774193"
    } },
    "metadata": { "description": "5212 Wolfies building the future of liquid NFTs on Cronos…" },
    "blacklisted": 0
  }]
}

Errors

Caveats

• Ranking is by 30-day CRO volume, refreshed on a ~5-minute server-side cache; positions can lag trades by a few minutes.
• Volumes/floors are CRO-denominated decimal strings.
• holders / totalSupply appear only for ERC721 collections; ERC1155 items omit both keys.
• *_increase fields and stats.total.royalty are always "0" (kept for shape compatibility).
• Requests may be throttled at the edge; handle 429/503 with backoff.

GET /collections?address= — single-collection detail

GET https://api.ebisusbay.com/collections?address=0x…

With an address (or its alias collection) parameter, /collections switches to the detailed lookup path (shared with the legacy /collectioninfo endpoint) and returns the same item shape as the ranked list for exactly the requested collection(s). Supports CSV addresses, plus the full legacy filter/sort surface.

Request parameters (detail mode; names are case-insensitive)

Example

curl "https://api.ebisusbay.com/collections?address=0xce5cac89e25dbccd590090994919a5ef53bbd6c0"

# CSV addresses are allowed
curl "https://api.ebisusbay.com/collections?address=0xce5cac89e25dbccd590090994919a5ef53bbd6c0,0x719fdfb0ba006747a83438cc8900c8a2b35e0aff"

const address = "0xce5cac89e25dbccd590090994919a5ef53bbd6c0";
const res = await fetch(
  `https://api.ebisusbay.com/collections?address=${address}`
);
const body = await res.json();

// Detail mode does NOT abort on unknown parameters — HTTP 400 can still
// carry data (the opposite of the ranked list). Check for the
// `collections` key rather than the status.
if (!Array.isArray(body.collections) || body.collections.length === 0) {
  throw new Error(body.error ?? "Collection not found");
}

const [collection] = body.collections;
console.log(collection.name, collection.stats.total.floorPrice);

// Same envelope and item shape as the ranked list — reuse the
// CollectionsResponse / Collection interfaces from GET /collections.
const address = "0xce5cac89e25dbccd590090994919a5ef53bbd6c0";
const res = await fetch(
  `https://api.ebisusbay.com/collections?address=${address}`
);
const body = (await res.json()) as CollectionsResponse;
const collection = body.collections?.[0];
if (!collection) throw new Error(body.error ?? "Collection not found");

const floor: string = collection.stats.total.floorPrice ?? "0";

Response

Same envelope and item shape as the ranked list above. For a single address, totalCount is 1.

Real (live) example — GET /collections?address=0xce5cac89e25dbccd590090994919a5ef53bbd6c0 (trimmed):

{
  "status": 200, "page": 1, "totalCount": 1, "pageSize": 100, "totalPages": 1,
  "collections": [{
    "chain": 25,
    "verification": { "verified": true, "doxx": false, "kyc": false },
    "holders": "101", "totalSupply": "333",
    "address": "0xce5cac89e25dbccd590090994919a5ef53bbd6c0",
    "owner": "0x0dd35ff4f88ff8878488ac943fc783ea1468aa98", "ownerExt": null,
    "multiToken": false, "is1155": false,
    "name": "CronosEyezNFT", "slug": "cronoseyez", "listable": true,
    "stats": { "total": {
      "active": "2", "complete": "108", "sales": "108",
      "floorPrice": "209.000000000000000000",
      "avgSalePrice": "257.916666666666666666",
      "volume": "27854.999999999996",
      "volume30d": "0", "sales30d": "0"
    } },
    "metadata": { "description": "CronosEyez is a Generative Art Collection of 333 NFTs…" },
    "blacklisted": 0
  }]
}

Errors

Caveats

• Detail-mode unknown parameters DON'T abort — you get HTTP 400 with data (opposite of the ranked list, which aborts). Check for the collections key rather than the status.
• Stats come from the same ~5-minute live stats cache as the ranked list; a collection with no recent activity legitimately shows "0" windowed values.
• verification.doxx / kyc may be booleans or strings depending on stored data ("true"/"false" strings are converted to booleans; empty strings pass through).
• Requests may be throttled at the edge; handle 429/503 with backoff.

GET /v2/wallets

GET https://api.ebisusbay.com/v2/wallets

Returns the NFTs currently held by a wallet on Cronos (direct on-chain holdings, ERC721 and ERC1155), enriched with collection info, token metadata, best offer and last sale. This is the wallet-inventory endpoint aggregators use to render a user's Ebisu's Bay holdings.

Request parameters (names case-insensitive)

Example

curl "https://api.ebisusbay.com/v2/wallets?wallet=0x7ff3d5cc69766652495ab5c3323224cf6e2b3229&pageSize=25"

const wallet = "0x7ff3d5cc69766652495ab5c3323224cf6e2b3229";
const res = await fetch(
  `https://api.ebisusbay.com/v2/wallets?wallet=${wallet}&pageSize=25`
);
const body = await res.json();

// Legacy quirk: empty results reset `status` to 200 and can keep a stale
// validation message in `error` — check `nfts.length`, not the error field.
const nfts = Array.isArray(body.nfts) ? body.nfts : [];
for (const nft of nfts) {
  console.log(nft.collectionName, nft.nftId, nft.name);
}

interface WalletsResponse {
  status: number;
  error: string | null; // may hold a stale message on empty results
  page: number;
  totalCount: number;
  pageSize: number;
  totalPages: number;
  nfts?: WalletNft[];
}

interface WalletNft {
  nftId: string;
  nftAddress: string;
  chain: number;
  collection: { name?: string; slug?: string; blacklist?: number };
  collectionName: string;
  burnt: boolean;
  balance?: string; // ERC1155 only — quantity held
  owner: string;
  token_uri: string;
  is1155: boolean;
  market: Record<string, unknown>; // { listingCount? } for ERC1155 own-listings
  last_sale: Record<string, unknown>; // { price?, currency?, seller?, id?, uri? } — ERC721 only
  offer: Record<string, unknown>; // best offer: { id, hash, offerIndex, price, purchaser, uri }
  // Flattened token metadata follows (name, image, rank, attributes, …)
  [metadata: string]: unknown;
}

const wallet = "0x7ff3d5cc69766652495ab5c3323224cf6e2b3229";
const res = await fetch(
  `https://api.ebisusbay.com/v2/wallets?wallet=${wallet}&pageSize=25`
);
const body = (await res.json()) as WalletsResponse;
const nfts = body.nfts ?? [];

Response

Envelope: { status, error, page, totalCount, pageSize, totalPages, nfts[] } (error is null on clean requests).

Each nfts[] item:

Real (live) example — GET /v2/wallets?wallet=0x7ff3d5cc69766652495ab5c3323224cf6e2b3229&pageSize=1 (trimmed):

{
  "status": 200, "error": null, "page": 1, "totalCount": 6, "pageSize": 1, "totalPages": 6,
  "nfts": [{
    "nftId": "808",
    "nftAddress": "0x15730353272c88229a91804854078aa9b3a70448",
    "chain": 25,
    "collection": { "name": "CronosEyez Gen 2", "slug": "cronoseyez-gen2", "blacklist": 0 },
    "collectionName": "CronosEyez Gen 2",
    "burnt": false,
    "owner": "0x7ff3d5cc69766652495ab5c3323224cf6e2b3229",
    "token_uri": "https://ipfs.ebisusbay.com/ipfs/QmcC1dobZsMiaHiwEnvqtbrKcCfKPLsw382mmf1pAXYYRQ/808.json",
    "is1155": false,
    "market": {}, "last_sale": {}, "offer": {},
    "edition": 808, "name": "CronosEyezGen2#808",
    "image": "https://ipfs.ebisusbay.com/ipfs/Qmf2k1TqHXG5TD5Ed6E9Akx45qMyJbT2Y9J4w1wYGWCs7Y/808.png",
    "rank": null,
    "attributes": [{ "value": "goldGeometrik", "trait_type": "Background" }]
  }]
}

Errors

Caveats

• Holdings are direct on-chain ownership only — tokens deposited into staking contracts are not attributed to the depositor on this endpoint.
• listed, currency, minPrice, maxPrice, minListingTime, maxListingTime are accepted but the underlying legacy listing-join is dead: any of them silently produces an empty result (totalCount: 0). Don't use them.
• sortBy=receivedTimestamp (also the implicit default) and sortBy=price have no backing data — ordering degenerates to (collection address, token id).
• Empty results reset status to 200 even if an unknown parameter was flagged; check nfts.length, not the error message.
• Ryoshi Resources (0xce3f4e59834b5b52b301e075c5b3d427b6884b3d) token ids 100–1003 are always excluded (legacy static exclusion).
• last_sale only ever populates for ERC721 tokens.
• Requests may be throttled at the edge; handle 429/503 with backoff.

GET /marketdata

GET https://api.ebisusbay.com/marketdata

Marketplace-wide, all-time headline totals: number of sales, active listings, traded volume and royalties, plus the marketplace (Port) contract address. Single flat JSON object — the endpoint takes no parameters.

Request parameters

None. (Legacy quirk: sending ANY query parameter flips the HTTP status to 400 but the same full data body is still returned.)

Example

curl "https://api.ebisusbay.com/marketdata"

const fetchMarketData = async () => {
  const res = await fetch("https://api.ebisusbay.com/marketdata");
  return res.json();
};

let data = await fetchMarketData();
// Cold-cache quirk: right after a server restart a worker can briefly
// serve zeroed values — retry once if everything is "0".
if (data.totalSales === "0" && data.totalVolume === "0") {
  data = await fetchMarketData();
}
console.log(data.totalSales, data.totalVolume, data.contractAddress);

interface MarketData {
  totalSales: string; // all-time completed sales (listings + accepted offers)
  totalActive: string; // current active listing quantity
  totalVolume: string; // CRO-denominated decimal string
  totalRoyalties: string; // raw aggregate — not comparable to totalVolume
  contractAddress: string; // Ebisu's Bay marketplace (Port) contract
}

const res = await fetch("https://api.ebisusbay.com/marketdata");
const data = (await res.json()) as MarketData;

Response

Real (live) example:

{
  "totalSales": "961475",
  "totalActive": "50278",
  "totalVolume": "305621707.361405454999890000000000",
  "totalRoyalties": "399467010154809301808023.368684639573251962",
  "contractAddress": "0x7a3cdb2364f92369a602cae81167d0679087e6a3"
}

Errors

Caveats

• Figures are rematerialized server-side roughly every 5 minutes; immediately after a process restart a cold worker can briefly serve zeroed values (observed live) — retry once if all fields are "0".
• totalVolume is a CRO-denominated decimal; totalRoyalties is a raw aggregate and is not directly comparable to totalVolume.
• Requests may be throttled at the edge; handle 429/503 with backoff.

GET /api/gasless-listing/validator

GET https://api.ebisusbay.com/api/gasless-listing/validator

Rollout note: this is the drop-in replacement for the retired GET cms.ebisusbay.com/api/gasless-listing/validator. The endpoint is implemented and will be served at the public path above once the final routing lands — until then it may still answer 404 on the live host. The examples below are constructed from the implementation and its test fixtures, not live captures.

To purchase listings you need a short-lived, server-signed Approval. This endpoint validates the requested listings (they must all still be active), reconstructs the exact TradeShip Order tuples, computes the marketplace fee, and returns everything you pass to the on-chain fillOrders call — including the server signature that the contract verifies. It accepts both gasless listings (32-byte 0x… digest ids) and legacy Port listings (decimal ids), mixed freely in one request.

Request parameters (query string)

There is no chainId parameter: this endpoint is pinned to Cronos mainnet (chain 25), exactly like the legacy API.

Response (HTTP 200)

The payload is wrapped in a data envelope. Field set is exactly:

Order shape (each element of orderData):

OfferItem = { itemType, token, identifierOrCriteria, startAmount, endAmount }.

Realistic example (constructed from the implementation's parity-test fixtures — one gasless listing at 100 CRO + one legacy listing at 50 CRO; fee = 3.5% of 150 CRO = 5.25 CRO):

GET /api/gasless-listing/validator?address=0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
    &listingIds[]=0xabababababababababababababababababababababababababababababababab
    &listingIds[]=12345

{
  "data": {
    "expire": 1751698638,
    "feeAmount": "5250000000000000000",
    "feeToken": "0x0000000000000000000000000000000000000000",
    "filler": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
    "sigs": [
      "0x1111…(65-byte seller signature)…11",
      "0x000000000000000000000000000000000000000000000000000000000000000000000000000000"
    ],
    "signature": "0x2222…(65-byte server signature)…22",
    "orderData": [
      {
        "offerer": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
        "offerings": [{
          "itemType": 1,
          "token": "0xcccccccccccccccccccccccccccccccccccccccc",
          "identifierOrCriteria": "1001",
          "startAmount": "1", "endAmount": "1"
        }],
        "considerations": [{
          "itemType": 0,
          "token": "0x0000000000000000000000000000000000000000",
          "identifierOrCriteria": "0",
          "startAmount": "100000000000000000000", "endAmount": "100000000000000000000"
        }],
        "orderType": 0,
        "startAt": 1751696738, "endAt": 1751784138,
        "salt": "7"
      },
      {
        "offerer": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
        "offerings": [{
          "itemType": 6,
          "token": "0xcccccccccccccccccccccccccccccccccccccccc",
          "identifierOrCriteria": "12345",
          "startAmount": "1", "endAmount": "1"
        }],
        "considerations": [{
          "itemType": 0,
          "token": "0x0000000000000000000000000000000000000000",
          "identifierOrCriteria": "0",
          "startAmount": "50000000000000000000", "endAmount": "50000000000000000000"
        }],
        "orderType": 0,
        "startAt": 1751696738, "endAt": 9995868693,
        "salt": "0"
      }
    ]
  }
}

Every response carries cache-control: no-store (success AND error) — never cache it.

Errors

Errors are a flat {"error": "<string>"} body (no data envelope, no status field, no structured code).

Caveats

• The fee is a flat 350 bps (3.5%) and server-pinned. You cannot influence it, and you should NEVER recompute it client-side — ERC20-priced listings are converted into the native fee basis using server-side price data you can't reproduce exactly. Always take msg.value inputs from the response's feeAmount + orderData.
• The Approval expires 900 s (15 min) after issuance (expire field). If you haven't filled by then, re-fetch — the contract rejects expired approvals. Responses are cache-control: no-store; do not cache or reuse them across purchases.
• Cronos mainnet only (chain 25). There is no chainId parameter; zkEVM/testnets are not served by this endpoint.
• Errors are flat {error: string} with meaningful HTTP status codes (400/403/404/500). There is no error code field.
• No on-chain pre-validation is performed on the seller side (ownership, token approval): a listing that went stale between validation and fill (seller transferred or delisted the NFT, ERC1155 balance dropped, etc.) will make fillOrders revert. Simulate (eth_call/estimateGas) before broadcasting and be prepared to refresh the listing set and re-validate.
• All-or-nothing: if any requested id is inactive the whole request fails with 403 — drop the dead ids and re-request rather than retrying the same set.
• merchantsSeal is accepted but ignored — legacy membership/VIP fee discounts have been removed; there is no way to lower the fee.
• The Transak executor flow was removed: executor=transak returns 400. Other executor values are ignored (legacy behavior).
• When recipient is set, it becomes the filler — the fill transaction must be sent from the recipient address, or the contract rejects the Approval.
• Requests may be throttled at the edge; handle 429/503 with backoff.
• sigs blob lengths differ by design (65-byte real signatures vs the 39-byte legacy sentinel) — pass them through untouched; re-encoding or normalizing them breaks the on-chain Approval decoding.

Fill flow: browse → validate → fillOrders

Step 1 — find listings. GET /listings?state=0&collection=0x…&pageSize=… (see GET /listings). Collect listingId values (and note each listing's currency).

Step 2 — validate. GET /api/gasless-listing/validator?address=<buyer>&listingIds[]=<id1>&listingIds[]=<id2>. Keep the whole data object; you will pass its parts to the contract unmodified.

Step 3 — compute payment. The fee is always native; each order's price is in its consideration:

msg.value = feeAmount
          + Σ orderData[i].considerations[0].startAmount
              for every i where considerations[0].itemType == 0   // NATIVE

For ERC20-priced orders (considerations[0].itemType == 3), instead approve the TradeShip contract for startAmount of considerations[0].token before filling (the price is pulled via transferFrom; only the fee stays in msg.value).

Step 4 — fill on-chain. Call the TradeShip ("ship") contract on Cronos mainnet:

0x523d6f30c4aaca133daad97ee2a0c48235bff137

Function (payable):

function fillOrders(
    TradeshipCrates.Order[] calldata _orders,     // = data.orderData
    TradeshipCrates.Approval calldata _approval,  // = { expire, feeAmount, feeToken, filler, sigs }
    bytes calldata _serverSig                     // = data.signature
) external payable;

struct Order {
    address offerer;
    OfferItem[] offerings;
    OfferItem[] considerations;
    uint8   orderType;
    uint256 startAt;
    uint256 endAt;
    uint256 salt;
}
struct OfferItem {
    uint8   itemType;
    address token;
    uint256 identifierOrCriteria;
    uint256 startAmount;
    uint256 endAmount;
}
struct Approval {
    uint256 expire;
    uint256 feeAmount;
    address feeToken;
    address filler;
    bytes[] sigs;
}

The transaction must be sent from data.filler (the contract checks msg.sender == filler), and must land before data.expire.

Step 5 — handle failure. If the transaction reverts (commonly a stale listing), refetch the listing (GET /listings?listingId=…), drop ids whose state != 0 or valid != true, and repeat from Step 2. If the Approval aged past 900 s, just repeat Step 2.

Example — validate and fill

# Validate two listings for a buyer (-g keeps the [] brackets literal)
curl -g "https://api.ebisusbay.com/api/gasless-listing/validator?address=0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb&listingIds[]=0xabababababababababababababababababababababababababababababababab&listingIds[]=12345"

# Comma-separated ids work too
curl "https://api.ebisusbay.com/api/gasless-listing/validator?address=0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb&listingIds=0xabababababababababababababababababababababababababababababababab,12345"

// ethers v6
import { Contract, JsonRpcProvider, Wallet } from "ethers";

const SHIP_ADDRESS = "0x523d6f30c4aaca133daad97ee2a0c48235bff137";
const SHIP_ABI = [
  "function fillOrders((address offerer,(uint8 itemType,address token,uint256 identifierOrCriteria,uint256 startAmount,uint256 endAmount)[] offerings,(uint8 itemType,address token,uint256 identifierOrCriteria,uint256 startAmount,uint256 endAmount)[] considerations,uint8 orderType,uint256 startAt,uint256 endAt,uint256 salt)[] _orders,(uint256 expire,uint256 feeAmount,address feeToken,address filler,bytes[] sigs) _approval,bytes _serverSig) payable",
];

const provider = new JsonRpcProvider("https://evm.cronos.org"); // Cronos mainnet
const wallet = new Wallet(process.env.PRIVATE_KEY, provider);

const listingIds = [
  "0xabababababababababababababababababababababababababababababababab",
  "12345",
];

// 1) Validate — returns the signed Approval + Order tuples
const v = await fetch(
  `https://api.ebisusbay.com/api/gasless-listing/validator?address=${wallet.address}` +
    listingIds.map((id) => `&listingIds[]=${id}`).join("")
);
if (!v.ok) throw new Error((await v.json()).error); // flat { error: string }
const { data } = await v.json();

// 2) msg.value = server-pinned fee + every NATIVE-priced order's amount.
//    Never recompute the fee yourself — always use data.feeAmount.
const value = data.orderData.reduce(
  (sum, o) =>
    o.considerations[0].itemType === 0
      ? sum + BigInt(o.considerations[0].startAmount)
      : sum,
  BigInt(data.feeAmount)
);

// 3) Fill — MUST be sent from data.filler, before data.expire (15 min)
const ship = new Contract(SHIP_ADDRESS, SHIP_ABI, wallet);
const approval = {
  expire: data.expire,
  feeAmount: data.feeAmount,
  feeToken: data.feeToken,
  filler: data.filler,
  sigs: data.sigs,
};
// Simulate first — fills revert if a listing went stale after validation
await ship.fillOrders.staticCall(data.orderData, approval, data.signature, {
  value,
});
const tx = await ship.fillOrders(data.orderData, approval, data.signature, {
  value,
});
await tx.wait();

// ethers v6
import { Contract, JsonRpcProvider, Wallet } from "ethers";

interface OfferItem {
  itemType: number; // 0 NATIVE · 1 ERC721 · 2 ERC1155 · 3 ERC20 · 6 LEGACY_LISTING
  token: string;
  identifierOrCriteria: string;
  startAmount: string;
  endAmount: string;
}

interface Order {
  offerer: string;
  offerings: OfferItem[];
  considerations: OfferItem[];
  orderType: number; // 0 SELL_NFT_NATIVE · 2 SELL_NFT_TOKEN
  startAt: number;
  endAt: number;
  salt: string;
}

interface ValidatorData {
  expire: number; // unix seconds — Approval expires 900 s after issuance
  feeAmount: string; // wei, native CRO, server-pinned flat 350 bps
  feeToken: string; // always the zero address
  filler: string; // fillOrders MUST be sent from this address
  sigs: string[]; // per-order maker signatures, index-aligned with orderData
  signature: string; // server signature — the _serverSig argument
  orderData: Order[];
}

const SHIP_ADDRESS = "0x523d6f30c4aaca133daad97ee2a0c48235bff137";
const SHIP_ABI = [
  "function fillOrders((address offerer,(uint8 itemType,address token,uint256 identifierOrCriteria,uint256 startAmount,uint256 endAmount)[] offerings,(uint8 itemType,address token,uint256 identifierOrCriteria,uint256 startAmount,uint256 endAmount)[] considerations,uint8 orderType,uint256 startAt,uint256 endAt,uint256 salt)[] _orders,(uint256 expire,uint256 feeAmount,address feeToken,address filler,bytes[] sigs) _approval,bytes _serverSig) payable",
];

const provider = new JsonRpcProvider("https://evm.cronos.org"); // Cronos mainnet
const wallet = new Wallet(process.env.PRIVATE_KEY ?? "", provider);

const listingIds: string[] = [
  "0xabababababababababababababababababababababababababababababababab",
  "12345",
];

const v = await fetch(
  `https://api.ebisusbay.com/api/gasless-listing/validator?address=${wallet.address}` +
    listingIds.map((id) => `&listingIds[]=${id}`).join("")
);
if (!v.ok) {
  const err = (await v.json()) as { error: string };
  throw new Error(err.error); // flat { error: string }
}
const { data } = (await v.json()) as { data: ValidatorData };

// msg.value = server-pinned fee + every NATIVE-priced order's amount
const value = data.orderData.reduce(
  (sum, o) =>
    o.considerations[0]?.itemType === 0
      ? sum + BigInt(o.considerations[0].startAmount)
      : sum,
  BigInt(data.feeAmount)
);

const ship = new Contract(SHIP_ADDRESS, SHIP_ABI, wallet);
const approval = {
  expire: data.expire,
  feeAmount: data.feeAmount,
  feeToken: data.feeToken,
  filler: data.filler,
  sigs: data.sigs,
};
// Simulate first — fills revert if a listing went stale after validation
await ship.fillOrders.staticCall(data.orderData, approval, data.signature, {
  value,
});
const tx = await ship.fillOrders(data.orderData, approval, data.signature, {
  value,
});
await tx.wait();

Disclaimer

This content is for informational purposes only and does not constitute financial, investment, or legal advice. Blockchain technology and decentralized finance involve significant risks, including the potential loss of all funds. All interactions with Ebisu's Bay and its affiliated services — including trading NFTs, swapping, bridging, and any other on-chain activities — are performed entirely at your own risk. You are solely responsible for your own decisions and due diligence. Ebisu's Bay makes no guarantees regarding the performance, security, or value of any tokens, NFTs, or DeFi protocols.