Crate zenodo_rs 

zenodo-rs

Async Rust client for core Zenodo workflows.

It covers deposition create/update/publish flows, safe draft reuse versus newversion, published-record lookup, latest-version resolution, and downloads behind a small typed API for automation and CI jobs built on top of the Zenodo REST API.

Start Here

• Use ZenodoClient for the main entrypoint.
• Use workflow for safe draft, publish, edit, and version helpers.
• Use records for published-record lookup, DOI resolution, and search.
• Use downloads for file and archive downloads.
• Use DepositMetadataUpdate and UploadSpec to describe what you want to publish.

Install

[dependencies]
zenodo-rs = "0.1"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

Optional features:

• checksums: validate Zenodo md5: checksums when downloading to a path
• indicatif: implement TransferProgress for indicatif::ProgressBar
• rustls-ring-tls: default Rustls transport using the Ring crypto provider, avoiding aws-lc-sys
• rustls-tls: backward-compatible reqwest/rustls transport using the AWS-LC-backed Rustls provider
• rustls-no-provider: advanced Rustls transport for applications that install their own process-wide rustls::crypto::CryptoProvider
• native-tls: use reqwest with native-tls instead of Rustls

The TLS features are mutually exclusive. Use default-features = false before selecting a non-default TLS backend.

Read Example

use zenodo_rs::ZenodoClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = ZenodoClient::from_sandbox_env()?;
    let record = client.get_record_by_doi_str("10.5281/zenodo.123").await?;
    let _ = record.id;

    Ok(())
}

Publish Example

use zenodo_rs::{
    AccessRight, Auth, DepositMetadataUpdate, UploadSpec, UploadType, ZenodoClient,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = ZenodoClient::new(Auth::new("token"))?;
    let metadata = DepositMetadataUpdate::builder()
        .title("Example dataset")
        .upload_type(UploadType::Dataset)
        .description_html("<p>Example upload</p>")
        .creator_named("Doe, Jane")
        .access_right(AccessRight::Open)
        .build()?;
    let files = UploadSpec::from_named_paths([("artifact.tar.gz", "target/release.tar.gz")])?;

    let published = client
        .create_and_publish_dataset(&metadata, files)
        .await?;
    let _ = published.record.id;

    Ok(())
}

Authentication

• ZENODO_TOKEN is the standard env var for the production service at zenodo.org.
• ZENODO_SANDBOX_TOKEN is the sandbox equivalent for sandbox.zenodo.org.
• Write flows usually need deposit:write and deposit:actions.

Progress Bars

Enable the indicatif feature if you want indicatif::ProgressBar to work directly with upload_path_with_progress, upload_reader_with_progress, reconcile_files_with_progress, and download_artifact_with_progress. Pass bar.clone() into the progress-aware upload and download helpers when you want a real terminal progress bar during transfers.

The full runnable example lives in the progress module docs.

Notes

Public download APIs use Zenodo IDs and selectors rather than raw URLs, and uploads require a known content length. For Zenodo-side behavior and token scopes, see the Zenodo developer docs.

Zenodo Limits and Retention

Zenodo’s current upload docs say a record can contain up to 100 files and a total of 50 GB (50,000,000,000 bytes), with uploads up to 50 GB by default and additional quota that can bring a record up to 200 GB. If you need larger payloads than Zenodo is a good fit for, consider internetarchive-rs. Zenodo does not publish an SLA; instead, its principles page states a continuous-availability target of at least 99.7%, cites historical uptime of 99.98% (October 2019), and points to a public status page for live figures. Its preservation policy says items are retained for the lifetime of the repository, currently tied to CERN and described as at least the next 20 years; withdrawn records keep a tombstone page, DOI, and original URL. Zenodo only promises bit-level preservation, not future usability or understandability of deposited objects. zenodo-rs does not currently enforce the 100-file or 50 GB client-side limits: it validates duplicate/conflicting filenames and always sends an explicit Content-Length, but limit overflows are currently left for Zenodo to reject at request time. Sources: Manage files, Manage quota, General policies, Principles, Status page.

Re-exports

pub use client::Auth;

pub use client::ZenodoClient;

pub use client::ZenodoClientBuilder;

pub use downloads::DownloadStream;

pub use downloads::ResolvedDownload;

pub use endpoint::Endpoint;

pub use error::FieldError;

pub use error::ZenodoError;

pub use ids::BucketUrl;

pub use ids::ConceptRecId;

pub use ids::DepositionFileId;

pub use ids::DepositionId;

pub use ids::Doi;

pub use ids::DoiError;

pub use ids::RecordId;

pub use metadata::AccessRight;

pub use metadata::CommunityRef;

pub use metadata::CommunityRefBuilder;

pub use metadata::Contributor;

pub use metadata::ContributorBuilder;

pub use metadata::Creator;

pub use metadata::CreatorBuilder;

pub use metadata::DepositMetadataBuildError;

pub use metadata::DepositMetadataUpdate;

pub use metadata::DepositMetadataUpdateBuilder;

pub use metadata::GrantRef;

pub use metadata::GrantRefBuilder;

pub use metadata::LicenseRef;

pub use metadata::LicenseRefBuilder;

pub use metadata::MetadataEntryBuildError;

pub use metadata::RecordDate;

pub use metadata::RecordDateBuilder;

pub use metadata::RecordIdentifier;

pub use metadata::RecordIdentifierBuilder;

pub use metadata::RecordMetadata;

pub use metadata::RecordRelations;

pub use metadata::RecordVersionRelation;

pub use metadata::RelatedIdentifier;

pub use metadata::RelatedIdentifierBuilder;

pub use metadata::ResourceType;

pub use metadata::ResourceTypeBuilder;

pub use metadata::Subject;

pub use metadata::SubjectBuilder;

pub use metadata::UploadType;

pub use model::ArtifactInfo;

pub use model::BucketObject;

pub use model::DepositState;

pub use model::Deposition;

pub use model::DepositionFile;

pub use model::DepositionLinks;

pub use model::DepositionStatus;

pub use model::PersistentIdentifier;

pub use model::PublishedRecord;

pub use model::Record;

pub use model::RecordFile;

pub use model::RecordFileLinks;

pub use model::RecordLinks;

pub use model::RecordParent;

pub use model::RecordParentCommunities;

pub use model::RecordPids;

pub use model::RecordPublicationStatus;

pub use model::RecordStats;

pub use pagination::Page;

pub use poll::PollOptions;

pub use progress::TransferProgress;

pub use records::ArtifactSelector;

pub use records::RecordQuery;

pub use records::RecordQueryBuilder;

pub use records::RecordQueryStatus;

pub use records::RecordSelector;

pub use records::RecordSort;

pub use upload::FileReplacePolicy;

pub use upload::UploadSource;

pub use upload::UploadSpec;

Modules

client

Low-level typed Zenodo client operations.

downloads

Download helpers for record files and archives.

endpoint

Endpoint selection for production, sandbox, or custom Zenodo deployments.

error

Error types and HTTP error decoding for Zenodo responses.

ids

Small identifier newtypes used throughout the public API.

links

Helpers for resolving absolute and relative Zenodo links.

metadata

Typed metadata models for deposit updates and published records.

model

Core data models for depositions, records, and files.

pagination

Pagination types for Zenodo list and search responses.

poll

Polling configuration for asynchronous Zenodo state transitions.

progress

Progress reporting hooks for uploads and downloads.

records

Published-record search, retrieval, and latest-version helpers.

upload

Upload input types and file replacement policies.

workflow

Higher-level workflow helpers that encode Zenodo deposition lifecycles.