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()

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

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

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

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

await client.AddRelay("wss://relay.damus.io");
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(["wss://relay.damus.io"], 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("wss://relay.damus.io"),
    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: ["wss://relay.damus.io"],
    filter: filter2,
    timeout: 10.0
)
C#
var filter2 = new Filter().Kind(Kind.FromStd(KindStandard.TextNote)).Limit(5);
var events2 = await client.FetchEventsFrom(["wss://relay.damus.io"], 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


async def fetch():
    client = Client()

    await client.add_relay("wss://relay.damus.io")
    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(["wss://relay.damus.io"], 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()

    client.addRelay("wss://relay.damus.io")
    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("wss://relay.damus.io"),
        filter = filter2,
        timeout = Duration.ofSeconds(10L)
    )
}

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

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

    try await client.addRelay(url: "wss://relay.damus.io")
        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: ["wss://relay.damus.io"],
        filter: filter2,
        timeout: 10.0
    )
}
C#
using Nostr.Sdk;

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

        await client.AddRelay("wss://relay.damus.io");
        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(["wss://relay.damus.io"], 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");
}