The catalog,
JSON out.

No. The 20 welcome credits at signup work on the Research Agent only, so you can try the human-facing side without spending anything. The API is paid from the first call - machine traffic requires purchased credits. Same wallet, same formula for what a call costs; only the source of the balance differs.

The next call returns 402 Payment Required with error: "api_requires_paid" and a message pointing to the top-up page. Nothing partial is served, nothing silent is deducted; the client sees the block plainly and can decide when to top up. Rate-limit and welcome credits do not unblock the API - only a purchased balance does.

Hugging Face holds the sources. This holds the curation - which of two near-identical uploads is the same technique under a different name, which base a derivative actually came from when the metadata is wrong or absent, a published method classification you can disagree with and audit, the four indices, and a record of models that have since been pulled.

Poll aggregates, not the raw catalog. /models/historical-deletions/summary once a day (20 credits) tells you if this month's deletion count moved; if it did, /models/historical-deletions/list?since_month=YYYY-MM lists exactly what's new. For downloads, /market/anomalies (15 credits) surfaces the biggest spikes and drops across the whole catalog in one call - cheaper than pulling every model's /download-history yourself and diffing. Both endpoints are page-friendly, so a webhook-style loop stays within a few dozen credits per day.

Same underlying data, different shape. /models?delisted=dead is the normal listing endpoint filtered to tombstoned rows - full model records with every field, and the full filter arsenal (method, family, base, sort, pagination). /models/delisted is a stripped feed: id, name, last-seen downloads, when we noticed they were gone. Use the second for compliance dashboards that just need "what disappeared and when"; use the first when you also want the enrichment we already had on the model before it was pulled.

Indefinitely. When Hugging Face pulls a model, we flip is_delisted and freeze last_seen_at, but the record - method classification, README, README history, download timeline, base and family links - stays exactly where it was. That's the point: the Hub is where these get erased; this catalog is where they stay reachable. A specific record will only be removed if a takedown request forces it, and we'll say so in the row rather than silently blank it.

No. See Terms, section 10. Paging politely through what you need is fine; systematic reconstruction of the catalog is not.

Shipped. @abliteration/cli is on npm as version 1.0.0. Install it four ways: the one-liner at /install, npm install -g @abliteration/cli, brew install neymark/abliteration/abliteration, or Scoop on Windows. The command is abl. Docs live under abl --help.

abl splits commands into Auth (sign in, keys, balance) and Catalog (data). Add --json for machine-readable output. Set ABLITERATION_API_KEY to override the saved key, ABL_DEBUG=1 for stack traces on errors.

whoami and credits cost 5 cr each because the server has no dedicated /whoami or /credits endpoint — both commands piggyback on GET /api/v1/methods, the cheapest existing route, and read credits_remaining from its response. Use them from scripts sparingly; the response of every data call already echoes credits_remaining, so a long-running job can track its balance without probing. Run abl --help for the current list.

Yes. pip install abliteration gives you a typed Client covering every endpoint plus the same abl command the Node CLI installs. httpx under the hood, sync, Python 3.9+. Import: from abliteration import Client. It shares the ABLITERATION_API_KEY environment variable with the Node CLI, so the two tools coexist on one shell.

Yes. gem install abliteration installs a typhoeus-based client generated from the OpenAPI spec. Configure once and every route is a typed method: Abliteration.configure { |c| c.access_token = ENV['ABLITERATION_API_KEY'] }, then Abliteration::ModelsApi.new.list_models(method: 'M4', limit: 5). The envelope carries cost, credits_remaining and rate-limit metadata on every response.

Yes. cargo add abliteration pulls a reqwest-based client generated from the OpenAPI spec. One module per resource (models_api, methods_api, and so on) and typed serde models for every schema. Pass the key on the shared configuration and call:

use abliteration::apis::configuration::Configuration;
use abliteration::apis::models_api;

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("ABLITERATION_API_KEY").ok();

let result = models_api::list_models(
    &cfg, Some("M4"), None, None, None, None, None,
    None, None, None, Some(5), None,
)?;

Yes. npm install @abliteration/sdk installs a zero-dependency SDK that uses the standard fetch API - works in Node 18+ and modern browsers alike. It ships both a CommonJS build and an ES-module build, with full .d.ts types. This is the library the Node CLI (@abliteration/cli) is built on, so both share the same envelope shape and the same ABLITERATION_API_KEY convention.

import { Configuration, ModelsApi } from '@abliteration/sdk';

const cfg = new Configuration({
  accessToken: process.env.ABLITERATION_API_KEY,
});
const models = new ModelsApi(cfg);
const { data, cost, creditsRemaining } = await models.listModels({
  method: 'M4', limit: 5,
});

Yes. dotnet add package abliteration pulls a netstandard2.0 client generated from the OpenAPI spec - works with .NET Core 2.0+, .NET Framework 4.6.1+ and .NET 5 or later. One Api class per resource (ModelsApi, MethodsApi, and so on), typed models for every schema, async methods everywhere:

using abliteration.Api;
using abliteration.Client;

var config = new Configuration();
config.AccessToken = Environment.GetEnvironmentVariable("ABLITERATION_API_KEY");

var api = new ModelsApi(config);
var result = await api.ListModelsAsync(method: "M4", limit: 5);
foreach (var m in result.Data)
{
    Console.WriteLine($"{m.Id} - {m.Downloads}");
}

Yes. composer require abliteration/abliteration installs a Guzzle-based client generated from the OpenAPI spec. PHP 7.4 or 8+, PSR-4 autoload under Abliteration\Client\. One Api class per resource with typed models on every response:

<?php
require_once 'vendor/autoload.php';

$config = Abliteration\Client\Configuration::getDefaultConfiguration()
    ->setAccessToken(getenv('ABLITERATION_API_KEY'));

$api = new Abliteration\Client\Api\ModelsApi(
    new GuzzleHttp\Client(),
    $config,
);
$result = $api->listModels(method: 'M4', limit: 5);

foreach ($result->getData() as $m) {
    echo $m->getId() . ' - ' . $m->getDownloads() . PHP_EOL;
}

Yes. Add {:abliteration, "~> 0.1"} to your mix.exs deps. Tesla-based, Elixir 1.12+, one module per resource with typed structs:

key = System.get_env("ABLITERATION_API_KEY")
config = Abliteration.Connection.new(bearer: key)

{:ok, envelope} = Abliteration.Api.Models.list_models(
  config,
  method: "M4",
  limit: 5
)

Enum.each(envelope.data, fn m ->
  IO.puts("#{m.id} - #{m.downloads}")
end)

Yes. dart pub add abliteration installs a Dio-based client with immutable built_value models. Works in Dart 2.18+ and Flutter. Note: because of built_value, run dart run build_runner build once after install to materialise the .g.dart files.

import 'package:abliteration/abliteration.dart';
import 'package:dio/dio.dart';

final key = const String.fromEnvironment('ABLITERATION_API_KEY');
final client = Abliteration(
  dio: Dio(BaseOptions(
    baseUrl: 'https://abliteration.org/api/v1',
    headers: {'Authorization': 'Bearer $key'},
  )),
);

final response = await client.getModelsApi().listModels(
  method: 'M4',
  limit: 5,
);

for (final m in response.data!.data) {
  print('${m.id} - ${m.downloads}');
}

Yes. Add org.abliteration:cli:0.1.0 to your build - Java 8+ compatible, OkHttp + Gson under the hood, works fine from Kotlin too.

// Maven
<dependency>
    <groupId>org.abliteration</groupId>
    <artifactId>cli</artifactId>
    <version>0.1.0</version>
</dependency>

// Gradle (Kotlin DSL)
implementation("org.abliteration:cli:0.1.0")

// Usage
import org.abliteration.client.Configuration;
import org.abliteration.client.api.ModelsApi;
import org.abliteration.client.auth.HttpBearerAuth;

ApiClient client = Configuration.getDefaultApiClient();
HttpBearerAuth bearer = (HttpBearerAuth) client.getAuthentication("bearerAuth");
bearer.setBearerToken(System.getenv("ABLITERATION_API_KEY"));

var result = new ModelsApi(client).listModels(
    "M4", null, null, null, null, null, null, null, null, 5, null
);
result.getData().forEach(m ->
    System.out.println(m.getId() + " - " + m.getDownloads())
);