The Rust crates are published on crates.io as nostr and nostr-sdk. For protocol-only code:

[dependencies]
nostr = "0.45"

For a networked application:

[dependencies]
nostr-sdk = "0.45"

Both crates require Rust 1.85 or later. Start with default features; chapters that require another crate or an opt-in feature show it where it is used. See nostr and nostr-sdk feature lists.

Python 3.9 or later is required. Install the package from PyPI:

pip install nostr-sdk==0.45.1

Supported platforms

Prebuilt wheels contain the native library for these targets:

No running event loop

Normal client calls work inside asyncio.run. A custom database, websocket implementation, or admission policy can be called from an SDK-owned thread instead. If an asynchronous callback fails with no running event loop, register the application loop before constructing that callback:

import asyncio
from typing import cast

from nostr_sdk import uniffi_set_event_loop


async def configure_event_loop() -> None:
    loop = cast(asyncio.BaseEventLoop, asyncio.get_running_loop())
    uniffi_set_event_loop(loop)

Call this from inside the application’s running async entry point, not at module import time.

Install exactly one package for the target runtime from the NostrDevKit npm organization.

npm install @nostrdevkit/nostr-sdk-node@0.45.1

npm install @nostrdevkit/nostr-sdk-web@0.45.1

npm install @nostrdevkit/nostr-sdk-react-native@0.45.1

Select one artifact for the application target:

dependencies {
    implementation("org.nostrdevkit:nostr-sdk:0.45.1")     // Android, minSdk 21
    implementation("org.nostrdevkit:nostr-sdk-jvm:0.45.1") // JVM 11+
    implementation("org.nostrdevkit:nostr-sdk-kmp:0.45.1") // Kotlin Multiplatform
}

Types are imported from org.nostrdevkit.sdk. The Android artifact requires API 21 or later, the standalone JVM artifact requires Java 11 or later, and the KMP JVM target requires Java 17.

Supported platforms

JNA dependency

Some Gradle configurations do not expose the binding’s JNA dependency to application code. If compilation fails with class file for com.sun.jna.Pointer not found, add JNA explicitly for the selected target:

dependencies {
    implementation("net.java.dev.jna:jna:5.17.0@aar") // Android
    implementation("net.java.dev.jna:jna:5.15.0")     // JVM
}

Use only the line matching the target. Kotlin Multiplatform projects should add the JVM dependency to jvmMain and the AAR variant to androidMain.

Add the nostr-sdk-swift repository in Xcode, or declare the package directly:

.package(url: "https://github.com/nostrdevkit/nostr-sdk-swift", exact: "0.45.1")

Supported platforms

.NET 6 or later is required. Install the package from NuGet:

dotnet add package Nostr.Sdk --version 0.45.1

Supported platforms

use nostr_sdk::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let keys = Keys::generate();
    let client = Client::default();

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

    let event = EventBuilder::new(Kind::TextNote, "Hello from Nostr Dev Kit!").finalize(&keys)?;
    let output = client.send_event(&event).await?;
    println!("Published {} to {:?}", output.id(), output.success);

    Ok(())
}

import asyncio

from nostr_sdk import (
    Client,
    EventBuilder,
    Kind,
    KindStandard,
    Keys,
    RelayUrl,
)


async def main() -> None:
    keys = Keys.generate()
    client = Client()

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

    event = EventBuilder(
        Kind.from_std(KindStandard.TEXT_NOTE), "Hello from Nostr Dev Kit!"
    ).finalize(keys)
    output = await client.send_event(event)
    print(f"Published {output.id.to_bech32()} to {output.success}")

if __name__ == "__main__":
    asyncio.run(main())

package rust.nostr.snippets

import kotlinx.coroutines.runBlocking
import org.nostrdevkit.sdk.*

suspend fun publishHello() {
    val keys = Keys.generate()
    val client = Client()

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

    val event = EventBuilder(
        Kind.fromStd(KindStandard.TEXT_NOTE),
        "Hello from Nostr Dev Kit!",
    ).finalize(keys)
    val output = client.sendEvent(event)
    println("Published ${output.id.toBech32()} to ${output.success}")

}

fun main() = runBlocking {
    publishHello()
}

import Foundation
import NostrSDK

func publishHello() async throws {
    let keys = Keys.generate()
    let client = Client()

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

    let event = try EventBuilder(
        kind: Kind.fromStd(e: .textNote),
        content: "Hello from Nostr Dev Kit!"
    ).finalize(signer: keys)
    let output = try await client.sendEvent(event: event)
    print("Published \(try output.id.toBech32()) to \(output.success)")

}

Call publishHello() from an asynchronous application entry point.

namespace Snippets;

using Nostr.Sdk;

public static class ClientExample
{
    public static async Task PublishHello()
    {
        var keys = Keys.Generate();
        var client = new Client();

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

        var @event = new EventBuilder(
            Kind.FromStd(KindStandard.TextNote),
            "Hello from Nostr Dev Kit!"
        ).Finalize(keys);
        var output = await client.SendEvent(@event);
        Console.WriteLine($"Published {output.Id.ToBech32()} to {string.Join(", ", output.Success)}");

    }
}

Call ClientExample.PublishHello() from an asynchronous entry point.

use nostr::prelude::*;

fn keys_example() -> Result<(), Box<dyn std::error::Error>> {
    let keys = Keys::generate();
    let public_key = keys.public_key();
    let encoded = public_key.to_bech32()?;
    let parsed = PublicKey::parse(&encoded)?;

    assert_eq!(parsed, public_key);
    println!("Public key: {encoded}");
    Ok(())
}

from nostr_sdk import Event, EventBuilder, Filter, Kind, KindStandard, Keys, PublicKey, Timestamp

def keys_example() -> None:
    keys = Keys.generate()
    public_key = keys.public_key()
    encoded = public_key.to_bech32()
    parsed = PublicKey.parse(encoded)

    assert parsed == public_key
    print(f"Public key: {encoded}")

import org.nostrdevkit.sdk.*

fun keysExample() {
    val keys = Keys.generate()
    val publicKey = keys.publicKey()
    val encoded = publicKey.toBech32()
    val parsed = PublicKey.parse(encoded)

    check(parsed == publicKey)
    println("Public key: $encoded")
}

import NostrSDK

func keysExample() throws {
    let keys = Keys.generate()
    let publicKey = keys.publicKey()
    let encoded = try publicKey.toBech32()
    let parsed = try PublicKey.parse(publicKey: encoded)

    print("Public key: \(try parsed.toBech32())")
}

using Nostr.Sdk;

public static class CoreExample
{

    public static void KeysExample()
    {
        var keys = Keys.Generate();
        var publicKey = keys.PublicKey();
        var encoded = publicKey.ToBech32();
        var parsed = PublicKey.Parse(encoded);

        Console.WriteLine($"Public key: {parsed.ToBech32()}");
    }
}

use nostr::prelude::*;

fn event_example() -> Result<(), Box<dyn std::error::Error>> {
    let keys = Keys::generate();
    let event = EventBuilder::new(Kind::TextNote, "Hello, Nostr!").finalize(&keys)?;
    event.verify()?;

    let decoded = Event::from_json(event.as_json())?;
    decoded.verify()?;
    println!("Event ID: {}", decoded.id.to_bech32()?);
    Ok(())
}

from nostr_sdk import Event, EventBuilder, Filter, Kind, KindStandard, Keys, PublicKey, Timestamp

def event_example() -> None:
    keys = Keys.generate()
    event = EventBuilder(
        Kind.from_std(KindStandard.TEXT_NOTE), "Hello, Nostr!"
    ).finalize(keys)
    assert event.verify()

    decoded = Event.from_json(event.as_json())
    assert decoded.verify()
    print(f"Event ID: {decoded.id().to_bech32()}")

import org.nostrdevkit.sdk.*

fun eventExample() {
    val keys = Keys.generate()
    val event = EventBuilder(
        Kind.fromStd(KindStandard.TEXT_NOTE),
        "Hello, Nostr!",
    ).finalize(keys)
    check(event.verify())

    val decoded = Event.fromJson(event.asJson())
    check(decoded.verify())
    println("Event ID: ${decoded.id().toBech32()}")
}

import NostrSDK

func eventExample() throws {
    let keys = Keys.generate()
    let event = try EventBuilder(
        kind: Kind.fromStd(e: .textNote),
        content: "Hello, Nostr!"
    ).finalize(signer: keys)
    precondition(event.verify())

    let decoded = try Event.fromJson(json: event.asJson())
    precondition(decoded.verify())
    print("Event ID: \(try decoded.id().toBech32())")
}

using Nostr.Sdk;

public static class CoreExample
{

    public static void EventExample()
    {
        var keys = Keys.Generate();
        var @event = new EventBuilder(
            Kind.FromStd(KindStandard.TextNote),
            "Hello, Nostr!"
        ).Finalize(keys);
        if (!@event.Verify()) throw new InvalidOperationException("Invalid event");

        var decoded = Event.FromJson(@event.AsJson());
        if (!decoded.Verify()) throw new InvalidOperationException("Invalid decoded event");
        Console.WriteLine($"Event ID: {decoded.Id().ToBech32()}");
    }
}

use nostr::prelude::*;

fn filter_example() {
    let public_key = Keys::generate().public_key();
    let filter = Filter::new()
        .author(public_key)
        .kind(Kind::TextNote)
        .since(Timestamp::now())
        .limit(20);

    println!("Filter: {}", filter.as_json());
}

from nostr_sdk import Event, EventBuilder, Filter, Kind, KindStandard, Keys, PublicKey, Timestamp

def filter_example() -> None:
    public_key = Keys.generate().public_key()
    filter = (
        Filter()
        .author(public_key)
        .kind(Kind.from_std(KindStandard.TEXT_NOTE))
        .since(Timestamp.now())
        .limit(20)
    )

    print(f"Filter: {filter.as_json()}")

import org.nostrdevkit.sdk.*

fun filterExample() {
    val publicKey = Keys.generate().publicKey()
    val filter = Filter()
        .author(publicKey)
        .kind(Kind.fromStd(KindStandard.TEXT_NOTE))
        .since(Timestamp.now())
        .limit(20u)

    println("Filter: ${filter.asJson()}")
}

import NostrSDK

func filterExample() throws {
    let publicKey = Keys.generate().publicKey()
    let filter = Filter()
        .author(author: publicKey)
        .kind(kind: Kind.fromStd(e: .textNote))
        .since(timestamp: Timestamp.now())
        .limit(limit: 20)

    print("Filter: \(try filter.asJson())")
}

using Nostr.Sdk;

public static class CoreExample
{

    public static void FilterExample()
    {
        var publicKey = Keys.Generate().PublicKey();
        var filter = new Filter()
            .Author(publicKey)
            .Kind(Kind.FromStd(KindStandard.TextNote))
            .Since(Timestamp.Now())
            .Limit(20);

        Console.WriteLine($"Filter: {filter.AsJson()}");
    }
}

Rust provides the stores as separate crates. Add the SQLite store to the existing SDK dependencies:

[dependencies]
nostr-gossip-sqlite = "0.45"

For an ephemeral store, use this dependency instead:

nostr-gossip-memory = "0.45"

use nostr_gossip_sqlite::prelude::NostrGossipSqlite;
use nostr_sdk::prelude::*;

async fn build_gossip_client() -> Result<Client, Box<dyn std::error::Error>> {
    let gossip = NostrGossipSqlite::open("./data/gossip.sqlite").await?;
    let client = Client::builder().gossip(gossip).build();

    client
        .add_relay("wss://relay.damus.io")
        .capabilities(RelayCapabilities::DISCOVERY)
        .await?;
    client
        .add_relay("wss://purplepag.es")
        .capabilities(RelayCapabilities::DISCOVERY)
        .await?;
    client.connect().await;

    Ok(client)
}

from nostr_sdk import (
    Client,
    ClientBuilder,
    NostrGossip,
    RelayCapabilities,
    RelayUrl,
)


async def build_gossip_client() -> Client:
    gossip = await NostrGossip.sqlite("./data/gossip.sqlite")
    client = ClientBuilder().gossip(gossip).build()
    capabilities = RelayCapabilities.discovery()

    await client.add_relay(
        RelayUrl.parse("wss://relay.damus.io"), capabilities=capabilities
    )
    await client.add_relay(
        RelayUrl.parse("wss://purplepag.es"), capabilities=capabilities
    )
    await client.connect()

    return client

import org.nostrdevkit.sdk.*

suspend fun buildGossipClient(databasePath: String): Client {
    val gossip = NostrGossip.sqlite(databasePath)
    val client = ClientBuilder().gossip(gossip).build()
    val capabilities = RelayCapabilities.discovery()

    client.addRelay(RelayUrl.parse("wss://relay.damus.io"), capabilities)
    client.addRelay(RelayUrl.parse("wss://purplepag.es"), capabilities)
    client.connect()

    return client
}

On Android, pass a path inside the application files directory.

import NostrSDK

func buildGossipClient(databasePath: String) async throws -> Client {
    let gossip = try await NostrGossip.sqlite(path: databasePath)
    let client = ClientBuilder().gossip(gossip: gossip).build()
    let capabilities = RelayCapabilities.discovery()

    _ = try await client.addRelay(
        url: try RelayUrl.parse(url: "wss://relay.damus.io"),
        capabilities: capabilities
    )
    _ = try await client.addRelay(
        url: try RelayUrl.parse(url: "wss://purplepag.es"),
        capabilities: capabilities
    )
    await client.connect()

    return client
}

Pass a path inside Application Support or another application-owned directory.

namespace Snippets;

using Nostr.Sdk;

public static class GossipExample
{
    public static async Task<Client> BuildGossipClient(string databasePath)
    {
        var gossip = await NostrGossip.Sqlite(databasePath);
        var client = new ClientBuilder().Gossip(gossip).Build();
        var capabilities = RelayCapabilities.Discovery();

        await client.AddRelay(RelayUrl.Parse("wss://relay.damus.io"), capabilities);
        await client.AddRelay(RelayUrl.Parse("wss://purplepag.es"), capabilities);
        await client.Connect();

        return client;
    }
}

Add the backend alongside nostr-sdk:

[dependencies]
nostr-lmdb = "0.45"

use nostr_lmdb::NostrLmdb;
use nostr_sdk::prelude::*;

async fn query_database() -> Result<(), Box<dyn std::error::Error>> {
    let database = NostrLmdb::open("./data/nostr").await?;
    let client = ClientBuilder::default().database(database).build();

    let filter = Filter::new().kind(Kind::TextNote).limit(20);
    let events = client.database().query(filter).await?;
    println!("Found {} stored events", events.len());

    Ok(())
}

from nostr_sdk import (
    ClientBuilder,
    Filter,
    Kind,
    KindStandard,
    NostrLmdb,
    RelayUrl,
    SyncDirection,
    SyncOptions,
)

async def query_database() -> None:
    database = await NostrLmdb.open("./data/nostr")
    client = ClientBuilder().database(database).build()

    filter = Filter().kind(Kind.from_std(KindStandard.TEXT_NOTE)).limit(20)
    events = await client.database().query(filter)
    print(f"Found {len(events)} stored events")

import org.nostrdevkit.sdk.*

suspend fun queryDatabase() {
    val database = NostrLmdb.open("./data/nostr")
    val client = ClientBuilder().database(database).build()

    val filter = Filter()
        .kind(Kind.fromStd(KindStandard.TEXT_NOTE))
        .limit(20u)
    val events = client.database().query(filter)
    println("Found ${events.size} stored events")
}

On Android, use a path inside the application files directory rather than a relative path.

import Foundation
import NostrSDK

func queryDatabase(path: String) async throws {
    let database = try await NostrLmdb.open(path: path)
    let client = ClientBuilder().database(database: database).build()

    let filter = Filter()
        .kind(kind: Kind.fromStd(e: .textNote))
        .limit(limit: 20)
    let events = try await client.database().query(filter: filter)
    print("Found \(events.count) stored events")
}

Pass a URL-derived path inside Application Support or another application-owned directory.

using Nostr.Sdk;

public static class DatabaseExample
{

    public static async Task QueryDatabase(string path)
    {
        var database = await NostrLmdb.Open(path);
        var client = new ClientBuilder().Database(database).Build();

        var filter = new Filter()
            .Kind(Kind.FromStd(KindStandard.TextNote))
            .Limit(20);
        var events = await client.Database().Query(filter);
        Console.WriteLine($"Found {events.Length} stored events");
    }
}

use std::time::Duration;

use nostr_sdk::prelude::*;

async fn stream_events() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::default();
    client.add_relay("wss://relay.damus.io").await?;
    client.connect().await;

    let filter = Filter::new().kind(Kind::TextNote).limit(20);
    let mut stream = client
        .stream_events(filter)
        .timeout(Duration::from_secs(10))
        .await?;

    while let Some((relay_url, result)) = stream.next().await {
        match result {
            Ok(event) => println!("{relay_url}: {}", event.as_json()),
            Err(error) => eprintln!("{relay_url}: {error}"),
        }
    }

    Ok(())
}

import asyncio
from datetime import timedelta

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

async def stream_events() -> None:
    client = Client()
    await client.add_relay(RelayUrl.parse("wss://relay.damus.io"))
    await client.connect()

    filter = Filter().kind(Kind.from_std(KindStandard.TEXT_NOTE)).limit(20)
    stream = await client.stream_events(
        ReqTarget.auto([filter]), timeout=timedelta(seconds=10)
    )

    while item := await stream.next():
        if item.event is not None:
            print(f"{item.relay_url}: {item.event.as_json()}")
        elif item.error is not None:
            print(f"{item.relay_url}: {item.error}")

import java.time.Duration
import kotlinx.coroutines.runBlocking
import org.nostrdevkit.sdk.*

suspend fun streamEvents() {
    val client = Client()
    client.addRelay(RelayUrl.parse("wss://relay.damus.io"))
    client.connect()

    val filter = Filter()
        .kind(Kind.fromStd(KindStandard.TEXT_NOTE))
        .limit(20u)
    val stream = client.streamEvents(
        ReqTarget.auto(listOf(filter)),
        timeout = Duration.ofSeconds(10),
    )

    while (true) {
        val item = stream.next() ?: break
        val event = item.event
        val error = item.error
        when {
            event != null -> println("${item.relayUrl}: ${event.asJson()}")
            error != null -> System.err.println("${item.relayUrl}: $error")
        }
    }

}

import Foundation
import NostrSDK

func streamEvents() async throws {
    let client = Client()
    let relay = try RelayUrl.parse(url: "wss://relay.damus.io")
    _ = try await client.addRelay(url: relay)
    await client.connect()

    let filter = Filter()
        .kind(kind: Kind.fromStd(e: .textNote))
        .limit(limit: 20)
    let stream = try await client.streamEvents(
        target: ReqTarget.auto(filters: [filter]),
        timeout: 10.0
    )

    while let item = await stream.next() {
        if let event = item.event {
            print("\(item.relayUrl): \(try event.asJson())")
        } else if let error = item.error {
            print("\(item.relayUrl): \(error)")
        }
    }

}

using Nostr.Sdk;

public static class ReadExample
{

    public static async Task StreamEvents()
    {
        var client = new Client();
        await client.AddRelay(RelayUrl.Parse("wss://relay.damus.io"));
        await client.Connect();

        var filter = new Filter()
            .Kind(Kind.FromStd(KindStandard.TextNote))
            .Limit(20);
        using var stream = await client.StreamEvents(
            ReqTarget.Auto([filter]),
            timeout: TimeSpan.FromSeconds(10)
        );

        while (await stream.Next() is { } item)
        {
            if (item.Event is { } @event)
            {
                Console.WriteLine($"{item.RelayUrl}: {@event.AsJson()}");
            }
            else if (item.Error is { } error)
            {
                Console.Error.WriteLine($"{item.RelayUrl}: {error}");
            }
        }

    }
}

use std::time::Duration;

use nostr_sdk::prelude::*;

async fn fetch_events() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::default();
    client.add_relay("wss://relay.damus.io").await?;
    client.connect().await;

    let filter = Filter::new().kind(Kind::TextNote).limit(20);
    let events = client
        .fetch_events(filter)
        .timeout(Duration::from_secs(10))
        .await?;

    for event in events {
        println!("{}", event.as_json());
    }

    Ok(())
}

import asyncio
from datetime import timedelta

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

async def fetch_events() -> None:
    client = Client()
    await client.add_relay(RelayUrl.parse("wss://relay.damus.io"))
    await client.connect()

    filter = Filter().kind(Kind.from_std(KindStandard.TEXT_NOTE)).limit(20)
    events = await client.fetch_events(
        ReqTarget.auto([filter]), timeout=timedelta(seconds=10)
    )

    for event in events:
        print(event.as_json())

import java.time.Duration
import kotlinx.coroutines.runBlocking
import org.nostrdevkit.sdk.*

suspend fun fetchEvents() {
    val client = Client()
    client.addRelay(RelayUrl.parse("wss://relay.damus.io"))
    client.connect()

    val filter = Filter()
        .kind(Kind.fromStd(KindStandard.TEXT_NOTE))
        .limit(20u)
    val events = client.fetchEvents(
        ReqTarget.auto(listOf(filter)),
        timeout = Duration.ofSeconds(10),
    )

    for (event in events) {
        println(event.asJson())
    }

}

import Foundation
import NostrSDK

func fetchEvents() async throws {
    let client = Client()
    let relay = try RelayUrl.parse(url: "wss://relay.damus.io")
    _ = try await client.addRelay(url: relay)
    await client.connect()

    let filter = Filter()
        .kind(kind: Kind.fromStd(e: .textNote))
        .limit(limit: 20)
    let events = try await client.fetchEvents(
        target: ReqTarget.auto(filters: [filter]),
        timeout: 10.0
    )

    for event in events {
        print(try event.asJson())
    }

}

using Nostr.Sdk;

public static class ReadExample
{

    public static async Task FetchEvents()
    {
        var client = new Client();
        await client.AddRelay(RelayUrl.Parse("wss://relay.damus.io"));
        await client.Connect();

        var filter = new Filter()
            .Kind(Kind.FromStd(KindStandard.TextNote))
            .Limit(20);
        var events = await client.FetchEvents(
            ReqTarget.Auto([filter]),
            timeout: TimeSpan.FromSeconds(10)
        );

        foreach (var @event in events)
        {
            Console.WriteLine(@event.AsJson());
        }

    }
}

use nostr_sdk::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::default();
    client.add_relay("wss://relay.damus.io").await?;
    client.connect().await;

    let mut notifications = client.notifications();
    let filter = Filter::new().kind(Kind::TextNote).since(Timestamp::now());
    let subscription = client.subscribe(filter).await?;

    while let Some(notification) = notifications.next().await {
        if let ClientNotification::Event {
            relay_url,
            subscription_id,
            event,
        } = notification
        {
            if &subscription_id == subscription.id() {
                println!("Received {} from {relay_url}", event.id);
                break;
            }
        }
    }

    client.unsubscribe(subscription.id()).await?;
    Ok(())
}

import asyncio

from nostr_sdk import (
    Client,
    ClientNotification,
    Filter,
    Kind,
    KindStandard,
    RelayUrl,
    ReqTarget,
    Timestamp,
)


async def main() -> None:
    client = Client()
    await client.add_relay(RelayUrl.parse("wss://relay.damus.io"))
    await client.connect()

    notifications = client.notifications()
    filter = (
        Filter()
        .kind(Kind.from_std(KindStandard.TEXT_NOTE))
        .since(Timestamp.now())
    )
    subscription = await client.subscribe(ReqTarget.auto([filter]))

    while notification := await notifications.next():
        if isinstance(notification, ClientNotification.NEW_EVENT):
            if notification.subscription_id == subscription.id:
                print(
                    f"Received {notification.event.id().to_bech32()} "
                    f"from {notification.relay_url}"
                )
                break

    await client.unsubscribe(subscription.id)


if __name__ == "__main__":
    asyncio.run(main())

package rust.nostr.snippets

import kotlinx.coroutines.runBlocking
import org.nostrdevkit.sdk.*

suspend fun receiveLiveEvent() {
    val client = Client()
    client.addRelay(RelayUrl.parse("wss://relay.damus.io"))
    client.connect()

    val notifications = client.notifications()
    val filter = Filter()
        .kind(Kind.fromStd(KindStandard.TEXT_NOTE))
        .since(Timestamp.now())
    val subscription = client.subscribe(ReqTarget.auto(listOf(filter)))

    while (true) {
        when (val notification = notifications.next() ?: break) {
            is ClientNotification.NewEvent -> {
                if (notification.subscriptionId == subscription.id) {
                    println("Received ${notification.event.id().toBech32()} from ${notification.relayUrl}")
                    break
                }
            }
            else -> Unit
        }
    }

    client.unsubscribe(subscription.id)
}

fun main() = runBlocking {
    receiveLiveEvent()
}

import Foundation
import NostrSDK

func receiveLiveEvent() async throws {
    let client = Client()
    let relay = try RelayUrl.parse(url: "wss://relay.damus.io")
    _ = try await client.addRelay(url: relay)
    await client.connect()

    let notifications = client.notifications()
    let filter = Filter()
        .kind(kind: Kind.fromStd(e: .textNote))
        .since(timestamp: Timestamp.now())
    let subscription = try await client.subscribe(
        target: ReqTarget.auto(filters: [filter])
    )

    while let notification = await notifications.next() {
        if case let .newEvent(relayUrl, subscriptionId, event) = notification,
           subscriptionId == subscription.id {
            print("Received \(try event.id().toBech32()) from \(relayUrl)")
            break
        }
    }

    _ = try await client.unsubscribe(subscriptionId: subscription.id)
}

namespace Snippets;

using Nostr.Sdk;

public static class LiveExample
{
    public static async Task ReceiveLiveEvent()
    {
        var client = new Client();
        await client.AddRelay(RelayUrl.Parse("wss://relay.damus.io"));
        await client.Connect();

        ClientNotificationStream notifications = client.Notifications();
        Filter filter = new Filter()
            .Kind(Kind.FromStd(KindStandard.TextNote))
            .Since(Timestamp.Now());
        SubscribeOutput subscription = await client.Subscribe(ReqTarget.Auto([filter]));

        while (await notifications.Next() is { } notification)
        {
            if (notification is ClientNotification.NewEvent item &&
                item.SubscriptionId == subscription.Id)
            {
                Console.WriteLine($"Received {item.Event.Id().ToBech32()} from {item.RelayUrl}");
                break;
            }
        }

        await client.Unsubscribe(subscription.Id);
    }
}

use nostr_lmdb::NostrLmdb;
use nostr_sdk::prelude::*;

async fn sync_events() -> Result<(), Box<dyn std::error::Error>> {
    let database = NostrLmdb::open("./data/nostr").await?;
    let client = ClientBuilder::default().database(database).build();

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

    let filter = Filter::new().kind(Kind::TextNote).limit(20);
    let opts = SyncOptions::default().direction(SyncDirection::Down);
    let output = client.sync(filter).opts(opts).await?;
    println!("Sync result: {output:?}");

    Ok(())
}

from nostr_sdk import (
    ClientBuilder,
    Filter,
    Kind,
    KindStandard,
    NostrLmdb,
    RelayUrl,
    SyncDirection,
    SyncOptions,
)

async def sync_events() -> None:
    database = await NostrLmdb.open("./data/nostr")
    client = ClientBuilder().database(database).build()

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

    filter = (
        Filter()
        .kind(Kind.from_std(KindStandard.TEXT_NOTE))
        .limit(20)
    )
    opts = SyncOptions().direction(SyncDirection.DOWN)
    output = await client.sync(filter, opts=opts)
    print(output)

import org.nostrdevkit.sdk.*

suspend fun syncEvents() {
    val database = NostrLmdb.open("./data/nostr")
    val client = ClientBuilder().database(database).build()

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

    val filter = Filter()
        .kind(Kind.fromStd(KindStandard.TEXT_NOTE))
        .limit(20u)
    val opts = SyncOptions().direction(SyncDirection.DOWN)
    val output = client.sync(filter, opts = opts)
    println(output)
}

import Foundation
import NostrSDK

func syncEvents(path: String) async throws {
    let database = try await NostrLmdb.open(path: path)
    let client = ClientBuilder().database(database: database).build()

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

    let filter = Filter()
        .kind(kind: Kind.fromStd(e: .textNote))
        .limit(limit: 20)
    let opts = SyncOptions().direction(direction: .down)
    let output = try await client.sync(filter: filter, opts: opts)
    print(output)
}

Pass a URL-derived path inside Application Support or another application-owned directory.

using Nostr.Sdk;

public static class DatabaseExample
{

    public static async Task SyncEvents(string path)
    {
        var database = await NostrLmdb.Open(path);
        var client = new ClientBuilder().Database(database).Build();

        await client.AddRelay(RelayUrl.Parse("wss://relay.damus.io"));
        await client.Connect();

        var filter = new Filter()
            .Kind(Kind.FromStd(KindStandard.TextNote))
            .Limit(20);
        var opts = new SyncOptions().Direction(SyncDirection.Down);
        var output = await client.Sync(filter, opts: opts);
        Console.WriteLine(output);
    }
}

Enable the relay API and add the database used by the example:

[dependencies]
nostr-lmdb = "0.45"
nostr-sdk = { version = "0.45", features = ["local-relay"] }

use std::time::Duration;

use nostr_lmdb::NostrLmdb;
use nostr_sdk::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let database = NostrLmdb::open("./data/relay").await?;
    let relay = LocalRelay::builder().database(database).port(7777).build();

    // Start the relay.
    relay.run().await?;

    println!("Relay listening on {}", relay.url().await);

    // Keep the process running
    loop {
        tokio::time::sleep(Duration::from_secs(60)).await;
    }
}

import asyncio

from nostr_sdk import LocalRelayBuilder, NostrLmdb


async def main() -> None:
    database = await NostrLmdb.open("./data/relay")
    relay = LocalRelayBuilder().database(database).port(7777).build()

    await relay.run()
    print(f"Relay URL: {await relay.url()}")

if __name__ == "__main__":
    asyncio.run(main())

package rust.nostr.snippets

import kotlinx.coroutines.runBlocking
import org.nostrdevkit.sdk.LocalRelayBuilder
import org.nostrdevkit.sdk.NostrLmdb

suspend fun runEmbeddedRelay() {
    val database = NostrLmdb.open("./data/relay")
    val relay = LocalRelayBuilder()
        .database(database)
        .port(7777u)
        .build()

    relay.run()
    println("Relay URL: ${relay.url()}")

}

fun relayMain() = runBlocking {
    runEmbeddedRelay()
}

On Android, replace the example path with one inside the application files directory.

import Foundation
import NostrSDK

func runEmbeddedRelay(path: String) async throws {
    let database = try await NostrLmdb.open(path: path)
    let relay = LocalRelayBuilder()
        .database(database: database)
        .port(port: 7777)
        .build()

    try await relay.run()
    print("Relay URL: \(await relay.url())")
}

Pass a URL-derived path inside Application Support or another application-owned directory.

namespace Snippets;

using Nostr.Sdk;

public static class RelayExample
{
    public static async Task RunEmbeddedRelay(string path)
    {
        var database = await NostrLmdb.Open(path);
        var relay = new LocalRelayBuilder()
            .Database(database)
            .Port(7777)
            .Build();

        await relay.Run();
        Console.WriteLine($"Relay URL: {await relay.Url()}");
    }
}