Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Fetching events

Request the events and wait until all relays return the result.

Initialize the client

For fetching events is usually1 not required a signer, so we can create a Client without signer. Then, add the relays and connect.

Rust
let client = Client::default();

client.add_relay("wss://relay.damus.io").await?;
client.connect().await;
Python
client = Client()

relay_url = RelayUrl.parse("wss://relay.damus.io")
await client.add_relay(relay_url)
await client.connect()
JavaScript
let client = new Client();

await client.addRelay("wss://relay.damus.io")
await client.connect();
Kotlin
val client = Client()

val relayUrl = RelayUrl.parse("wss://relay.damus.io")
client.addRelay(relayUrl)
client.connect()
Swift
let client = Client()

let relayUrl = try RelayUrl.parse(url: "wss://relay.damus.io")
try await client.addRelay(url: relayUrl)
await client.connect()
C#
var client = new Client();

var relayUrl = RelayUrl.Parse("wss://relay.damus.io");
await client.AddRelay(relayUrl);
await client.Connect();
Flutter
Client client = Client();

await client.addRelay(url: "wss://relay.damus.io");
await client.connect();

1. In some cases is required the signer to preform the NIP-42 authentication (i.e., to access to private/paid relays).

Fetch

After building the client and connecting the relays, we can create a Filter and perform our first fetch.

Rust
let filter: Filter = Filter::new().kind(Kind::Metadata).limit(3);
let events: Events = client.fetch_events(filter, Duration::from_secs(10)).await?;
Python
filter: Filter = Filter().kind(Kind.from_std(KindStandard.METADATA)).limit(3)
events: Events = await client.fetch_events(filter, timedelta(seconds=10))
JavaScript
let filter1 = new Filter().kind(Kind.fromStd(KindStandard.Metadata)).limit(3);
let events1 = await client.fetchEvents(filter1, Duration.fromSecs(10));
Kotlin
val filter1: Filter = Filter().kind(Kind.fromStd(KindStandard.METADATA)).limit(3u)
val events1: Events = client.fetchEvents(filter = filter1, timeout = Duration.ofSeconds(10L))
Swift
let filter1 = Filter().kind(kind: Kind.fromStd(e: KindStandard.metadata)).limit(limit: 3)
let events1 = try await client.fetchEvents(filter: filter1, timeout: 10.0)
C#
var filter1 = new Filter().Kind(Kind.FromStd(KindStandard.Metadata)).Limit(3);
var events1 = await client.FetchEvents(filter1, TimeSpan.FromSeconds(10));
Flutter
Filter filter1 = Filter().kind(kind: 0).limit(limit: BigInt.from(3));
Events events1 = await client.fetchEvents(filter: filter1, timeout: Duration(seconds: 10));

Fetch from specific relays

You may want to fetch the events from specific relays:

Rust
let filter: Filter = Filter::new().kind(Kind::TextNote).limit(5);
let events: Events = client
    .fetch_events_from(["wss://relay.damus.io"], filter, Duration::from_secs(10))
    .await?;
Python
filter: Filter = Filter().kind(Kind.from_std(KindStandard.TEXT_NOTE)).limit(5)
events: Events = await client.fetch_events_from([relay_url], filter, timedelta(seconds=10))
JavaScript
let filter2 = new Filter().kind(Kind.fromStd(KindStandard.TextNote)).limit(5);
let events2 = await client.fetchEventsFrom(["wss://relay.damus.io"], filter2, Duration.fromSecs(10));
Kotlin
val filter2: Filter = Filter().kind(Kind.fromStd(KindStandard.TEXT_NOTE)).limit(5u)
val events2: Events = client.fetchEventsFrom(
    urls = listOf(relayUrl),
    filter = filter2,
    timeout = Duration.ofSeconds(10L)
)
Swift
let filter2 = Filter().kind(kind: Kind.fromStd(e: KindStandard.textNote)).limit(limit: 5)
let events2 = try await client.fetchEventsFrom(
    urls: [relayUrl],
    filter: filter2,
    timeout: 10.0
)
C#
var filter2 = new Filter().Kind(Kind.FromStd(KindStandard.TextNote)).Limit(5);
var events2 = await client.FetchEventsFrom([relayUrl], filter2, TimeSpan.FromSeconds(10));
Flutter
Filter filter2 = Filter().kind(kind: 1).limit(limit: BigInt.from(5));
Events events2 = await client.fetchEventsFrom(urls: ["wss://relay.damus.io"], filter: filter2, timeout: Duration(seconds: 10));

Warning

The specified relays must be already added and connected!

Full example

Rust
use std::time::Duration;

use nostr_sdk::prelude::*;

pub async fn fetch() -> Result<()> {
    let client = Client::default();

    client.add_relay("wss://relay.damus.io").await?;
    client.connect().await;

    let filter: Filter = Filter::new().kind(Kind::Metadata).limit(3);
    let events: Events = client.fetch_events(filter, Duration::from_secs(10)).await?;

    let filter: Filter = Filter::new().kind(Kind::TextNote).limit(5);
    let events: Events = client
        .fetch_events_from(["wss://relay.damus.io"], filter, Duration::from_secs(10))
        .await?;

    Ok(())
}
Python
import asyncio
from datetime import timedelta

from nostr_sdk import Client, Filter, Events, Kind, KindStandard, RelayUrl


async def fetch():
    client = Client()

    relay_url = RelayUrl.parse("wss://relay.damus.io")
    await client.add_relay(relay_url)
    await client.connect()

    filter: Filter = Filter().kind(Kind.from_std(KindStandard.METADATA)).limit(3)
    events: Events = await client.fetch_events(filter, timedelta(seconds=10))

    filter: Filter = Filter().kind(Kind.from_std(KindStandard.TEXT_NOTE)).limit(5)
    events: Events = await client.fetch_events_from([relay_url], filter, timedelta(seconds=10))


if __name__ == '__main__':
   asyncio.run(fetch())
JavaScript
import {Client, Filter, Kind, KindStandard, Duration, loadWasmAsync} from "@rust-nostr/nostr-sdk";

async function fetch() {
    await loadWasmAsync();

    let client = new Client();

    await client.addRelay("wss://relay.damus.io")
    await client.connect();

    let filter1 = new Filter().kind(Kind.fromStd(KindStandard.Metadata)).limit(3);
    let events1 = await client.fetchEvents(filter1, Duration.fromSecs(10));

    let filter2 = new Filter().kind(Kind.fromStd(KindStandard.TextNote)).limit(5);
    let events2 = await client.fetchEventsFrom(["wss://relay.damus.io"], filter2, Duration.fromSecs(10));
}

fetch();
Kotlin
import java.time.Duration
import kotlinx.coroutines.runBlocking
import rust.nostr.sdk.*

suspend fun fetch() {
    val client = Client()

    val relayUrl = RelayUrl.parse("wss://relay.damus.io")
    client.addRelay(relayUrl)
    client.connect()

    val filter1: Filter = Filter().kind(Kind.fromStd(KindStandard.METADATA)).limit(3u)
    val events1: Events = client.fetchEvents(filter = filter1, timeout = Duration.ofSeconds(10L))

    val filter2: Filter = Filter().kind(Kind.fromStd(KindStandard.TEXT_NOTE)).limit(5u)
    val events2: Events = client.fetchEventsFrom(
        urls = listOf(relayUrl),
        filter = filter2,
        timeout = Duration.ofSeconds(10L)
    )
}

fun main() {
    runBlocking { fetch() }
}
Swift
import Foundation
import NostrSDK

func fetch() async throws {
    let client = Client()

    let relayUrl = try RelayUrl.parse(url: "wss://relay.damus.io")
    try await client.addRelay(url: relayUrl)
    await client.connect()

    let filter1 = Filter().kind(kind: Kind.fromStd(e: KindStandard.metadata)).limit(limit: 3)
    let events1 = try await client.fetchEvents(filter: filter1, timeout: 10.0)

    let filter2 = Filter().kind(kind: Kind.fromStd(e: KindStandard.textNote)).limit(limit: 5)
    let events2 = try await client.fetchEventsFrom(
        urls: [relayUrl],
        filter: filter2,
        timeout: 10.0
    )
}
C#
using Nostr.Sdk;

public class Fetch
{
    public static async Task Run()
    {
        var client = new Client();

        var relayUrl = RelayUrl.Parse("wss://relay.damus.io");
        await client.AddRelay(relayUrl);
        await client.Connect();
        
        var filter1 = new Filter().Kind(Kind.FromStd(KindStandard.Metadata)).Limit(3);
        var events1 = await client.FetchEvents(filter1, TimeSpan.FromSeconds(10));

        var filter2 = new Filter().Kind(Kind.FromStd(KindStandard.TextNote)).Limit(5);
        var events2 = await client.FetchEventsFrom([relayUrl], filter2, TimeSpan.FromSeconds(10));
    }
}
Flutter
import 'package:nostr_sdk/nostr_sdk.dart';

Future<void> fetch() async {
  Client client = Client();

  await client.addRelay(url: "wss://relay.damus.io");
  await client.connect();

  Filter filter1 = Filter().kind(kind: 0).limit(limit: BigInt.from(3));
  Events events1 = await client.fetchEvents(filter: filter1, timeout: Duration(seconds: 10));

  print("Fetched ${events1.len()} events");

  Filter filter2 = Filter().kind(kind: 1).limit(limit: BigInt.from(5));
  Events events2 = await client.fetchEventsFrom(urls: ["wss://relay.damus.io"], filter: filter2, timeout: Duration(seconds: 10));

  print("Fetched ${events2.len()} events");
}