Przejdź do treści
Biblioteka skilli
Programowanie · Integracja z narzędziem

deepgram-rust-management-api

/deepgram-rust-management-api

Wdraża w Rust operacje Deepgram na projektach, kluczach, członkach, zakresach, rozliczeniach, zaproszeniach i zużyciu, z flagami funkcji manage oraz API Deepgram::projects, keys, members, scopes, billing i usage.

Licencja
MIT
Ostatnia zmiana repozytorium
20.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
6
Przestarzałość

Brak sygnałów. Repozytorium zmienione 20.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Wdraża w Rust operacje Deepgram na projektach, kluczach, członkach, zakresach, rozliczeniach, zaproszeniach i zużyciu, z flagami funkcji manage oraz API Deepgram::projects, keys, members, scopes, billing i usage.

Oryginalny opis (EN)

Use when implementing Deepgram project, key, member, scope, billing, invitation, or usage operations from the Rust SDK, including manage feature flags and the real Deepgram::projects/keys/members/scopes/billing/usage APIs.

Jak działa

  1. When to use this product
  2. Authentication
  3. Quick start
  4. Quick start: projects + usage
  5. Key parameters
  6. API reference (layered)
  7. Gotchas
  8. Example files in this repo
  9. Central product skills
Sekcje z nagłówków SKILL.md, w oryginale · 129 linii, 544 słów
Podgląd SKILL.md
---
name: deepgram-rust-management-api
description: Use when implementing Deepgram project, key, member, scope, billing, invitation, or usage operations from the Rust SDK, including manage feature flags and the real Deepgram::projects/keys/members/scopes/billing/usage APIs.
---

# Using Deepgram Management API (Rust SDK)

Use this skill for project/account administration against Deepgram's Manage APIs.

## When to use this product

- Listing or updating projects.
- Managing project API keys, members, scopes, invitations, balances, and usage.
- Explaining which admin surfaces are available in the current crate.

## Authentication

For a management-only install:

```toml
[dependencies]
deepgram = { version = "0.12", default-features = false, features = ["manage"] }
tokio = { version = "1", features = ["full"] }
```

```rust
let dg = deepgram::Deepgram::new(std::env::var("DEEPGRAM_API_KEY")?)?;
```

- Manage APIs require a regular API key with `Token` auth.
- Temporary auth tokens created via `auth().grant(...)` do **not** work for Manage APIs.

## Quick start

## Quick start: projects + usage

```rust
use deepgram::{
    manage::{projects::options::Options as ProjectOptions, usage::get_usage_options},
    Deepgram,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DEEPGRAM_API_KEY")?;
    let project_id = std::env::var("DEEPGRAM_PROJECT_ID")?;
    let dg = Deepgram::new(&api_key)?;

    let projects = dg.projects().list().await?;
    println!("{projects:#?}");

    let project = dg.projects().get(&project_id).await?;
    println!("{project:#?}");

    let update = ProjectOptions::builder()
        .name("The Transcribinator")
        .company("Doofenshmirtz Evil Incorporated")
        .build();
    let message = dg.projects().update(&project_id, &update).await?;
    println!("{}", message.message);

    let usage_options = get_usage_options::Options::builder().build();
    let usage = dg.usage().get_usage(&project_id, &usage_options).await?;
    println!("{usage:#?}");

    Ok(())
}
```

## Key parameters

- Project APIs: `projects().list()`, `get(project_id)`, `update(project_id, &options)`, `delete(project_id)`.
- Key APIs: `keys().list(project_id)`, `get(project_id, key_id)`, `create(project_id, &options)`, `delete(project_id, key_id)`.
- Member APIs: `members().list_members(project_id)`, `remove_member(project_id, member_id)`.
- Scope APIs: `scopes().get_scope(project_id, member_id)`, `update_scope(project_id, member_id, scope)`.
- Billing APIs: `billing().list_balance(project_id)`, `get_balance(project_id, balance_id)`.
- Usage APIs: `usage().list_requests(...)`, `get_request(...)`, `get_usage(...)`, `get_fields(...)`.
- Invitation API: `invitations().leave_project(project_id)`.
- Models APIs: `models().get_models()`, `get_models_including_outdated()`, `get_model(model_id)`, `get_project_models(project_id)`, `get_project_models_including_outdated(project_id)`, `get_project_model(project_id, model_id)`. The listing calls take no arguments and return the latest model versions only; the `_including_outdated` variants also return non-latest versions.
- Self-hosted APIs: `self_hosted().list_distribution_credentials(project_id)`, `get_distribution_credentials(project_id, credentials_id)`, `create_distribution_credentials(project_id, &request)`, `delete_distribution_credentials(project_id, credentials_id)`. The credentials ID is a `Uuid`, and `create_distribution_credentials` returns the registry secret exactly once, so store it as soon as the call returns.

## API reference (layered)

1. **In-repo**
   - `src/manage/projects.rs`
   - `src/manage/keys.rs`
   - `src/manage/members.rs`
   - `src/manage/scopes.rs`
   - `src/manage/billing.rs`
   - `src/manage/usage.rs`
   - `src/manage/invitations.rs`
   - `src/manage/models.rs`
   - `src/manage/self_hosted.rs`
   - `examples/manage/*.rs`
2. **OpenAPI**
   - Raw spec: `https://developers.deepgram.com/openapi.yaml`
   - Examples: `https://developers.deepgram.com/reference/manage/usage/get`, `https://developers.deepgram.com/reference/manage/keys/list`
3. **AsyncAPI**
   - Not applicable for the Rust crate's current management surface
4. **Context7**
   - `/llmstxt/developers_deepgram_llms_txt`
5. **Product docs**
   - `https://developers.deepgram.com/reference/`
   - `https://developers.deepgram.com/docs/create-additional-api-keys`

## Gotchas

1. **Use API keys, not temp tokens.** `auth().grant(...)` explicitly does not authorize Manage APIs.
2. **Examples in `examples/manage/` are useful, but source files are the source of truth.** Prefer `src/manage/*.rs` when you need exact method names and return types.
3. **Most admin traffic stays on hosted Deepgram.** Even with `with_base_url(...)`, billing, usage, keys, members, invitations, projects, and scopes still target `https://api.deepgram.com`, as does the `/v1/auth/grant` token exchange. Two admin surfaces are the exception: `models()` and `self_hosted()` build their requests against the client's configured base URL, so a self-hosted client reaches `/v1/models` and its distribution-credentials paths on its own host.

## Example files in this repo

- `examples/manage/projects.rs`
- `examples/manage/keys.rs`
- `examples/manage/members.rs`
- `examples/manage/scopes.rs`
- `examples/manage/billing.rs`
- `examples/manage/usage.rs`
- `examples/manage/invitations.rs`
- `examples/manage/models.rs`
- `examples/manage/self_hosted_credentials.rs`

## Central product skills

For cross-language Deepgram product knowledge — the consolidated API reference, documentation finder, focused runnable recipes, third-party integration examples, and MCP setup — install the central skills:

```bash
npx skills add deepgram/skills
```

This SDK ships language-idiomatic code skills; `deepgram/skills` ships cross-language product knowledge (see `api`, `docs`, `recipes`, `examples`, `starters`, `setup-mcp`).

Wersje

W bazie nie ma innych skilli o nazwie deepgram-rust-management-api.

Migawka bazy z 13.11.2026 · wersja paczki 80e23a609dd0 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100deepgram-java-management-api
    Obsługuje w Javie interfejsy zarządzania Deepgram: projekty, modele projektu, klucze API, członków, zaproszenia, zużycie i rozliczenia przez client.manage().v1() oraz wykrywanie modeli think.
  • 100deepgram-go-management-api
    Obsługuje w Go punkty końcowe zarządzania Deepgram: projekty, klucze, członków, zakresy, zaproszenia, zużycie, salda, modele, wielokrotnego użytku konfiguracje agentów i zmienne agentów.
  • 100deepgram-python-management-api
    Obsługuje w Pythonie API zarządzania Deepgram: projekty, klucze API, członkowie, zaproszenia, użycie, rozliczenia, modele oraz konfiguracje Voice Agent wielokrotnego użytku.
  • 100deepgram-js-management-api
    Obsługuje w JavaScripcie i TypeScripcie API zarządzania Deepgram: projekty, klucze API, członkowie, zaproszenia, żądania, użycie, rozliczenia, modele i wykrywanie modeli think agenta.
  • 100deepgram-install-auth
    Instaluje SDK i CLI Deepgram oraz konfiguruje uwierzytelnianie, w tym klucze API, przy nowej integracji lub inicjalizacji Deepgram w projekcie.
  • 100deepgram-install-auth
    Instaluje SDK Deepgram i konfiguruje uwierzytelnianie, w tym klucze API i dane uwierzytelniające, przy nowej integracji lub inicjalizacji Deepgram w projekcie.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.