Everything you need to send your first request.

// Node.js 18+ (built-in fetch)
const res = await fetch("https://api.iteradian.com/rpc/v1/eth-mainnet", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-Api-Key": process.env.ITERADIAN_API_KEY,
  },
  body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_blockNumber", params: [] }),
});
const body = await res.json();
if (!res.ok) throw new Error(`HTTP ${res.status}: ${JSON.stringify(body)}`);
if (body.error) throw new Error(`RPC error ${body.error.code}: ${body.error.message}`);
console.log(BigInt(body.result));

import os
import requests

res = requests.post(
    "https://api.iteradian.com/rpc/v1/eth-mainnet",
    headers={"X-Api-Key": os.environ["ITERADIAN_API_KEY"]},
    json={"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []},
    timeout=35,
)
res.raise_for_status()
body = res.json()
if "error" in body:
    raise RuntimeError(body["error"])
print(int(body["result"], 16))

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`)
	req, err := http.NewRequest("POST", "https://api.iteradian.com/rpc/v1/eth-mainnet", bytes.NewReader(body))
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Api-Key", os.Getenv("ITERADIAN_API_KEY"))

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(res.StatusCode, string(out))
}

// Cargo.toml: reqwest = { version = "0.12", features = ["json"] },
//             serde_json = "1", tokio = { version = "1", features = ["full"] }
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("ITERADIAN_API_KEY")?;
    let body: Value = reqwest::Client::new()
        .post("https://api.iteradian.com/rpc/v1/eth-mainnet")
        .header("X-Api-Key", key)
        .json(&json!({ "jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": [] }))
        .send()
        .await?
        .error_for_status()?
        .json()
        .await?;
    println!("{}", body["result"]);
    Ok(())
}

using System.Net.Http;
using System.Text;

using var http = new HttpClient();
using var req = new HttpRequestMessage(HttpMethod.Post, "https://api.iteradian.com/rpc/v1/eth-mainnet");
req.Headers.Add("X-Api-Key", Environment.GetEnvironmentVariable("ITERADIAN_API_KEY"));
req.Content = new StringContent(
    "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_blockNumber\",\"params\":[]}",
    Encoding.UTF8,
    "application/json");

using var res = await http.SendAsync(req);
Console.WriteLine($"{(int)res.StatusCode} {await res.Content.ReadAsStringAsync()}");

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class BlockNumber {
    public static void main(String[] args) throws Exception {
        HttpRequest req = HttpRequest.newBuilder(URI.create("https://api.iteradian.com/rpc/v1/eth-mainnet"))
            .header("Content-Type", "application/json")
            .header("X-Api-Key", System.getenv("ITERADIAN_API_KEY"))
            .POST(HttpRequest.BodyPublishers.ofString(
                "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"eth_blockNumber\",\"params\":[]}"))
            .build();
        HttpResponse<String> res = HttpClient.newHttpClient()
            .send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.statusCode() + " " + res.body());
    }
}

<?php
$ch = curl_init("https://api.iteradian.com/rpc/v1/eth-mainnet");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Content-Type: application/json",
        "X-Api-Key: " . getenv("ITERADIAN_API_KEY"),
    ],
    CURLOPT_POSTFIELDS => json_encode([
        "jsonrpc" => "2.0", "id" => 1, "method" => "eth_blockNumber", "params" => [],
    ]),
]);
$body = json_decode(curl_exec($ch), true);
echo curl_getinfo($ch, CURLINFO_RESPONSE_CODE), " ", $body["result"] ?? json_encode($body), PHP_EOL;

// ethers v6
import { ethers } from "ethers";

const req = new ethers.FetchRequest("https://api.iteradian.com/rpc/v1/eth-mainnet");
req.setHeader("X-Api-Key", process.env.ITERADIAN_API_KEY);
const provider = new ethers.JsonRpcProvider(req);
console.log(await provider.getBlockNumber());

// viem
import { createPublicClient, http } from "viem";
import { mainnet } from "viem/chains";

const client = createPublicClient({
  chain: mainnet,
  transport: http("https://api.iteradian.com/rpc/v1/eth-mainnet", {
    fetchOptions: { headers: { "X-Api-Key": process.env.ITERADIAN_API_KEY } },
  }),
});
console.log(await client.getBlockNumber());

// @solana/web3.js
import { Connection } from "@solana/web3.js";

const connection = new Connection("https://api.iteradian.com/rpc/v1/sol-mainnet", {
  httpHeaders: { "X-Api-Key": process.env.ITERADIAN_API_KEY },
});
console.log(await connection.getSlot());

# web3.py
import os
from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://api.iteradian.com/rpc/v1/eth-mainnet",
    request_kwargs={"headers": {"X-Api-Key": os.environ["ITERADIAN_API_KEY"]}},
))
print(w3.eth.block_number)

HTTP/1.1 429 Too Many Requests

{
  "jsonrpc": "2.0",
  "id": null,
  "error": {
    "code": -32005,
    "message": "…",
    "data": { "retryAfter": 1, "allowed": 20, "cost": 1 }
  }
}

HTTP/1.1 403 Forbidden

{ "statusCode": 403, "message": "…", "error": "Forbidden" }

import { IteradianClient } from "@iteradian-rpc/sdk";

const client = new IteradianClient({ apiKey: process.env.ITERADIAN_API_KEY });

const res = await client.rpc.call("eth-mainnet", {
  jsonrpc: "2.0",
  id: 1,
  method: "eth_blockNumber",
  params: [],
});
console.log(res.result);

import os
from iteradian import IteradianClient

# Synchronous client (built on httpx).
client = IteradianClient(api_key=os.environ["ITERADIAN_API_KEY"])

res = client.rpc.call("eth-mainnet", {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_blockNumber",
    "params": [],
})
print(res["result"])

using Iteradian;

// .NET 6 and 8.
var client = new IteradianClient(
    "https://api.iteradian.com/api/v1",
    "https://api.iteradian.com");
client.SetApiKey(Environment.GetEnvironmentVariable("ITERADIAN_API_KEY"));

var res = await client.Rpc.CallAsync("eth-mainnet", new
{
    jsonrpc = "2.0",
    id = 1,
    method = "eth_blockNumber",
    @params = Array.Empty<object>(),
});
Console.WriteLine(res?["result"]);