Metadata-Version: 2.1
Name: suno-cli
Version: 2026.11.22.0
Summary: Suno music generation CLI by Ace Data Cloud
Project-URL: Homepage, https://github.com/AceDataCloud/SunoCli
Project-URL: Documentation, https://platform.acedata.cloud/documents/4da95d9d-7722-4a72-857d-bf6be86036e9
Project-URL: Repository, https://github.com/AceDataCloud/SunoCli
Project-URL: Issues, https://github.com/AceDataCloud/SunoCli/issues
Project-URL: Changelog, https://github.com/AceDataCloud/SunoCli/blob/main/CHANGELOG.md
Author-email: AceDataCloud <support@acedata.cloud>
Maintainer-email: AceDataCloud <support@acedata.cloud>
License: MIT
License-File: LICENSE
Keywords: acedata,acedatacloud,ai,audio,cli,command-line,generation,music,suno,suno-api
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Multimedia :: Sound/Audio
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Requires-Python: >=3.10
Requires-Dist: click>=8.1.0
Requires-Dist: httpx>=0.27.0
Requires-Dist: pydantic>=2.0.0
Requires-Dist: python-dotenv>=1.0.0
Requires-Dist: rich>=13.0.0
Provides-Extra: all
Requires-Dist: suno-cli[dev,release,test]; extra == 'all'
Provides-Extra: dev
Requires-Dist: mypy>=1.10.0; extra == 'dev'
Requires-Dist: pre-commit>=3.7.0; extra == 'dev'
Requires-Dist: ruff>=0.4.0; extra == 'dev'
Provides-Extra: release
Requires-Dist: build>=1.2.0; extra == 'release'
Requires-Dist: twine>=6.1.0; extra == 'release'
Provides-Extra: test
Requires-Dist: pytest-asyncio>=0.23.0; extra == 'test'
Requires-Dist: pytest-cov>=5.0.0; extra == 'test'
Requires-Dist: pytest>=8.0.0; extra == 'test'
Requires-Dist: respx>=0.21.0; extra == 'test'
Description-Content-Type: text/markdown

# Suno by Ace Data Cloud — CLI

## Install the Ace integration

This integration is maintained by **Ace Data Cloud** and uses your Ace API key. It is not an official client published by the model owner. Check the [PyPI package](https://pypi.org/project/suno-cli/) and its AceDataCloud repository before installing.

```bash
python -m pip install suno-cli
suno --help
suno models
```

The commands above show local help/reference information and do not submit a generation. Then follow **Get API Token** below: register/sign in, initialize General application if needed, create/copy an application key, and store it in the terminal's `ACEDATACLOUD_API_TOKEN` environment variable. Do not use a platform management token.

Generation follows your account's current service access, balance and pricing. Save the returned task ID and query that **same ID**; do not repeat generation while a task is pending.

```text
suno task <task-id>
suno wait <task-id> --interval 5
```

A successful command or running preview does not prove a completed media result. Check the task's terminal outcome and returned media link. [中文首次使用指南](https://github.com/AceDataCloud/Clis/blob/main/docs/SERVICE_PACKAGES_zh-CN.md) · [Service-name package directory](https://github.com/AceDataCloud/Clis/blob/main/docs/SERVICE_PACKAGES.md)


[![PyPI version](https://img.shields.io/pypi/v/suno-cli.svg)](https://pypi.org/project/suno-cli/)
[![PyPI downloads](https://img.shields.io/pypi/dm/suno-cli.svg)](https://pypi.org/project/suno-cli/)
[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![CI](https://github.com/AceDataCloud/SunoCli/actions/workflows/ci.yaml/badge.svg)](https://github.com/AceDataCloud/SunoCli/actions/workflows/ci.yaml)

A command-line tool for AI music generation using [Suno](https://suno.ai/) through the [AceDataCloud API](https://platform.acedata.cloud/?utm_source=opensource&utm_medium=referral&utm_campaign=evergreen).

Generate AI music, lyrics, and manage audio projects directly from your terminal — no MCP client required.

## Features

- **Music Generation** — Generate from prompts, custom lyrics, extend, cover, remaster, concat
- **Lyrics** — Generate lyrics, mashup, optimize style descriptions
- **Media Conversion** — Get MP4, WAV, MIDI, timing, extract vocals
- **Task Management** — Query tasks, batch query, wait with polling
- **Custom Models** — Train, inspect, generate with, and archive custom music models
- **Rich Output** — Beautiful terminal tables and panels via Rich
- **JSON Mode** — Machine-readable output with `--json` for piping
- **File Input** — Read lyrics from files with `@filename` syntax

## Quick Start

### 1. Get API Token

1. Open [Ace Data Cloud → Applications](https://platform.acedata.cloud/console/applications?utm_source=opensource&utm_medium=referral&utm_campaign=evergreen). Sign in, or register an account first.
2. Find **General application**. If it has not been created, choose **Initialize General Application**. A general key can use the services available to your account; a dedicated application's key is limited to its service. Check the required service/model access and [current pricing](https://platform.acedata.cloud/models?utm_source=opensource&utm_medium=referral&utm_campaign=evergreen).
3. Copy the **API Key** from the application card, or open **Keys / Manage Keys → Create** to create a separate key for this integration. Give it a recognizable name so you can revoke or rotate it independently.
4. When creating a key, review **Expiration Time**, **Set Usage Limitation**, and **Allowed APIs**. Enable only the restrictions you need, allow the operations you will call, then click **Create** and copy the token from the key list. Task lookup does not grant permission to submit a generation. Confirm the application's balance can cover your first request; any trial allowance is whatever your account currently displays.
5. Copy only the token value, without quotation marks, spaces, or `Bearer `. An API Key / API Token field expects this raw value; only a manually configured HTTP `Authorization` header needs the `Bearer ` prefix. A `platform-...` account-management token cannot replace a generation API key.

![Copy an application API key or open Manage Keys](https://raw.githubusercontent.com/AceDataCloud/NanoBananaDify/2522b2f57210597af2db866445319334a1677a23/_assets/tutorial/get-api-key-en.png)

![Create a separately named key with optional restrictions](https://raw.githubusercontent.com/AceDataCloud/NanoBananaDify/2522b2f57210597af2db866445319334a1677a23/_assets/tutorial/create-api-key-en.png)

Save the key in the client's credential store or the environment variable shown below. Never put it in a prompt, shared workflow, screenshot, or Git commit. If authentication fails, check the full copied value, application/service access, expiration, usage limit, and balance before creating another key.

### 2. Install

```bash
# Install with pip
pip install suno-cli

# Or with uv (recommended)
uv pip install suno-cli

# Or from source
git clone https://github.com/AceDataCloud/SunoCli.git
cd SunoCli
pip install -e .
```

### 3. Configure

```bash
# Set your API token
export ACEDATACLOUD_API_TOKEN=your_token_here

# Or use .env file
cp .env.example .env
# Edit .env with your token
```

### 4. Use

```bash
# Generate music from a prompt
suno generate "A happy birthday song with acoustic guitar"

# Generate with custom lyrics
suno custom -l "[Verse]\nHello world\n[Chorus]\nLa la la" -t "Hello" -s "pop, upbeat"

# Read lyrics from a file
suno custom -l @lyrics.txt -t "My Song" -s "rock, powerful"

# Generate lyrics
suno lyrics "A love song about the ocean at sunset"

# Check task status
suno task <task-id>

# Wait for completion with polling
suno wait <task-id> --interval 5

# Get MP4 video
suno mp4 <audio-id>

# List available models
suno models
```

## Commands

### Music Generation

| Command | Description |
|---------|-------------|
| `suno generate <prompt>` | Generate music from a text prompt (Inspiration Mode) |
| `suno custom` | Generate with custom lyrics, title, and style |
| `suno extend <audio_id>` | Extend an existing song from a timestamp |
| `suno cover <audio_id>` | Create a cover/remix version |
| `suno remaster <audio_id>` | Remaster a song to improve quality |
| `suno concat <audio_id>` | Merge extended segments into complete audio |
| `suno generate-persona <audio_id>` | Generate music using a saved persona |
| `suno generate-persona-vox <audio_id>` | Generate music using a persona's vocal style |
| `suno stems <audio_id>` | Separate a song into vocals + instrumental |
| `suno all-stems <audio_id>` | Separate a song into all individual stems |
| `suno replace-section <audio_id>` | Replace a time range with new content |
| `suno upload-extend <audio_id>` | Extend uploaded audio with AI continuation |
| `suno upload-cover <audio_id>` | Create a cover of uploaded audio |
| `suno mashup <id1> <id2>...` | Blend multiple songs into a mashup |
| `suno underpainting <audio_id>` | Add AI accompaniment to uploaded audio |
| `suno overpainting <audio_id>` | Add AI vocals to uploaded audio |
| `suno samples <audio_id>` | Add AI samples to uploaded audio |
| `suno inspo <audio_id>` | Generate a new song inspired by an existing audio |

### Cover with a specified voice

`cover` and `upload-cover` accept `--persona-id` to select a voice. A vocal gender preference is not a substitute for the voice ID, and no extra `vocal_gender` is needed.

Voices created by `suno voice` are private resources. To cover a song with one, create the voice, upload the source song with that voice's `persona_id`, then pass the returned `data.audio_id` and the same persona ID to `upload-cover`. Use the same service channel for voice creation, upload and cover; do not reuse an older audio ID that was not linked to this voice.

The following commands submit API requests; replace the placeholder IDs with the values returned by the preceding step:

```bash
suno voice "https://example.com/voice.mp3" --name "My Voice" --json
suno upload "https://example.com/my-song.mp3" --mode standard --persona-id "<persona_id>" --json
suno upload-cover "<data.audio_id>" --persona-id "<persona_id>" --style "jazz, smooth piano" --async --json
```

`upload --persona-id` requires a nonempty ID and supports only `--mode standard` (the default), not `enhanced`. Save the cover task ID and use `suno task` or `suno wait` with that same ID instead of resubmitting. Voice similarity depends on the reference material and generated result.

### Replace a section and review the full song

Use `--lyric` for the **local new lyrics** in the selected time range, not the whole song. For lyric edits, supply the same local text with `--prompt`; here it is lyrics, not a style or inspiration description. Existing lyric-only requests remain supported, but adding a prompt does not guarantee that the audio will sing every word.

The following submits a billable editing task. Replace the audio ID and times with your completed source song and its actual selection:

```bash
NEW_LYRICS=$'Evening winds across the quiet street\nWe sing the story where the rivers meet'
suno replace-section "<completed-audio-id>" --start 30 --end 50 \
  --lyric "$NEW_LYRICS" --prompt "$NEW_LYRICS" --model chirp-v6 --async --json
suno task "<returned-task-id>" --json
```

`--result-mode full_song` is the default: it returns two complete songs without another `concat`. After completion, inspect the task's `response.data` for the songs' `id`, `audio_url` and `duration`, then listen and select one. For manual selection before joining, use `--result-mode candidates`, choose a candidate's audio ID and run `suno concat "<candidate-audio-id>"`.

Listen to the source and use `suno timing "<completed-audio-id>"` to help select complete musical phrases. Match the new lyrics' length and rhythm to the selection. Full-song results need not match the source duration; `--duration` is only a generation option and cannot lock replacement length. Returned `lyric` is metadata, not a transcription: it may combine full lyrics when source timing is available or be empty otherwise. Neither new words in that field nor task success proves the edit was sung correctly.

For another edit, use the chosen **complete result's audio ID**, not its task ID or an unjoined candidate. Recheck its duration and time range; earlier coordinates can shift. Do not reuse the entire returned lyrics as local input. If words or duration are wrong, check the selection and the other result; retain the task ID, source audio ID, request fields and result audio for support rather than expecting more polling to change completed content.

### Processing request billing

Successful `suno lyrics` requests cost **0.08 Credits** each, even when several lyric candidates are returned. Successful `suno voice` creation costs **0.15 Credits** per request. Successful `suno stems` (`action=stems`) costs **0.56 Credits** per request, with vocals and accompaniment counted together. Failed requests are not charged; applicable consumption discounts follow the actual bill. These prices do not apply to other actions such as `all_stems` or `extract_stem`.

### Audio availability precheck

```bash
suno availability 33333333-3333-4333-8333-333333333333 --json
```

Replace the example UUID with the song's `audio_id` from a completed Suno task, not its `task_id`. `suno availability <audio_id>` calls authenticated `POST /suno/availability` synchronously before operations such as extend or cover. It currently consumes no Credits and does not submit a generation or poll a task.

A successful check returns `data.id` and `data.available: true`: positive evidence on the current channel, not a guarantee that a later operation will succeed. The state can change between the check and processing. Unknown availability returns an error (including `503 availability_unknown`), never `available: false`. Invalid audio ID format returns 400 at the API boundary; the CLI rejects non-UUID input locally. Authentication, rate-limit and upstream errors also exit nonzero without automatic retries; retain the returned task/trace IDs for support. `--json` preserves the full successful response, including `task_id` and `trace_id`; without it, the command prints the `data` object.

### Audio generation and processing failures

An `audio_id` identifies reference music for operations such as cover, extend and stem separation. A downloadable audio file does not guarantee that its ID remains available for further processing.

| HTTP status | Error code | Meaning |
|-------------|------------|---------|
| 500 | `api_error` | `the account may have been offline` |
| 500 | `suno_processing_unavailable` | Music processing is unavailable. |
| 500 | `suno_model_unavailable` | The selected model is unavailable for this operation. |
| 500 | `suno_processing_failed` | Music processing returned no audio. |

If one of these errors occurs, retain the original `task_id` (when available) and the error's `trace_id`, and contact support. The CLI displays the HTTP error body and exits nonzero; it does not automatically resubmit the operation. Do not treat a working download link as evidence that another processing attempt will succeed.

### Lyrics

| Command | Description |
|---------|-------------|
| `suno lyrics <prompt>` | Generate song lyrics from a prompt |
| `suno mashup-lyrics` | Generate mashup lyrics from two sources |
| `suno optimize-style <prompt>` | Optimize a style description |

### Media Conversion

| Command | Description |
|---------|-------------|
| `suno mp4 <audio_id>` | Get MP4 video version |
| `suno wav <audio_id>` | Get lossless WAV format |
| `suno midi <audio_id>` | Get MIDI data |
| `suno timing <audio_id>` | Get timing/subtitle data |
| `suno vocals <audio_id>` | Extract vocal track |

### Task Management

| Command | Description |
|---------|-------------|
| `suno task <task_id>` | Query a single task status |
| `suno tasks <id1> <id2>...` | Query multiple tasks at once |
| `suno wait <task_id>` | Wait for task completion with polling |

### Custom Models

| Command | Description |
|---------|-------------|
| `suno custom-model-create` | Train a model from 6–24 authorized audio URLs |
| `suno custom-model <model_id>` | Retrieve a custom model |
| `suno custom-models` | List custom models for the current application |
| `suno custom-model-generate <model_id>` | Generate a song with a ready custom model |
| `suno custom-model-delete <model_id>` | Archive a custom model |

### Utilities

| Command | Description |
|---------|-------------|
| `suno persona <audio_id>` | Create a saved voice style |
| `suno personas` | List saved voice styles |
| `suno persona-delete <persona_id>` | Delete a saved voice style |
| `suno voice <audio_url>` | Create a voice style from an external voice recording |
| `suno upload <audio_url>` | Upload external audio for processing |
| `suno availability <audio_id>` | Check positive evidence of audio availability before processing |
| `suno models` | List available Suno models |
| `suno actions` | List available API actions |
| `suno lyric-format` | Show lyrics formatting guide |
| `suno config` | Show current configuration |

`suno personas --user-id <user_id>` (`GET /suno/persona`) and
`suno persona-delete <persona_id>` (`DELETE /suno/persona`) are free of charge.
They still require an API token, but no additional billing-exemption header.
Creating a persona with `suno persona <audio_id> --name "My Voice"`
(`POST /suno/persona`) remains billed according to the API pricing rules.

## Global Options

```
--token TEXT    API token (or set ACEDATACLOUD_API_TOKEN env var)
--version       Show version
--help          Show help message
```

Most commands support:

```
--json          Output raw JSON (for piping/scripting)
--model TEXT    Suno model version (default: chirp-v6)
```

The `generate` and `custom` commands also support:

```
--duration INT  Target track length in seconds
```

`--negative-style` maps to the API's `negative_tags` field for custom generation (`suno custom`, which sends `custom: true`) and is also supported by `replace-section`. There is currently no fixed character limit for this field, but overly long input may still fail; keep it concise. The option on `suno generate` is preserved, but that command does not enable custom mode.

```bash
suno custom -l @lyrics.txt -t "My Song" -s "pop, upbeat" --negative-style "metal, harsh vocals"
```

### Processing boundaries and Inspo controls

`extend` and `upload-extend` require a positive `--continue-at`; fractional seconds
such as `30.792` are preserved. Lyrics guide only the new segment after that
boundary, not the earlier song. `samples --end` is required and must exceed
`--start` (default: 0). Replacement start/end are required, start is nonnegative,
and end must exceed start. End times must not exceed the source duration.

`inspo` accepts 1–4 `--audio-url` references without requiring a positional audio
ID. It supports `--instrumental`, `--persona-id`, `--custom` and `--lyric-prompt`;
auto-lyrics apply when custom mode has no lyrics. Use only authorized references.
Persona IDs identify voices, not songs. Persona-based generation and covers use
the voice ID; extension does not use an extra persona ID. Inspo/mashup voice
support depends on the selected service channel.

```bash
suno extend <audio-id> --continue-at 30.792 --lyric "[Verse] New lyrics"
suno replace-section <audio-id> --start 0 --end 10.5 --negative-style "metal"
suno inspo --audio-url https://example.com/authorized.mp3 --instrumental --async --json
```

`duration` is used only by the API's `generate` action (including the CLI's
`generate` and `custom` commands), is an integer from 10–360 seconds, and remains
a target rather than guaranteed output length. For `all-stems`, playable URLs
while processing do not mean every stem is complete; wait for the successful
terminal task outcome before using the complete set.

## Scripting & Piping

The `--json` flag outputs machine-readable JSON suitable for piping:

```bash
# Generate and extract task ID
TASK_ID=$(suno generate "rock song" --json | jq -r '.task_id')

# Wait for completion and get audio URL
suno wait $TASK_ID --json | jq -r '.data[0].audio_url'

# Batch generate from a file of prompts
while IFS= read -r prompt; do
  suno generate "$prompt" --json >> results.jsonl
done < prompts.txt
```

## Available Models

| Model | Version | Max Duration | Notes |
|-------|---------|-------------|-------|
| `chirp-v6` | V6 | — | Latest, best quality (default) |
| `chirp-v6-wild` | V6 Wild | — | V6 wild variant |
| `chirp-v6-mini` | V6 Mini | — | V6 compact variant |
| `chirp-v5-5` | V5.5 | 8 min | High quality |
| `chirp-v5` | V5 | 8 min | High quality |
| `chirp-v4-5-plus` | V4.5+ | 8 min | Enhanced quality |
| `chirp-v4-5` | V4.5 | 4 min | Vocal gender control |
| `chirp-v4` | V4 | 150s | Stable |
| `chirp-v3-5` | V3.5 | 120s | Fast |
| `chirp-v3-0` | V3 | 120s | Legacy |

## Configuration

### Environment Variables

| Variable | Description | Default |
|----------|-------------|---------|
| `ACEDATACLOUD_API_TOKEN` | API token from AceDataCloud | *Required* |
| `ACEDATACLOUD_API_BASE_URL` | API base URL | `https://api.acedata.cloud` |
| `SUNO_DEFAULT_MODEL` | Default model | `chirp-v6` |
| `SUNO_REQUEST_TIMEOUT` | Timeout in seconds | `1800` |

## Development

### Setup Development Environment

```bash
# Clone repository
git clone https://github.com/AceDataCloud/SunoCli.git
cd SunoCli

# Create virtual environment
python -m venv .venv
source .venv/bin/activate  # or `.venv\Scripts\activate` on Windows

# Install with dev dependencies
pip install -e ".[dev,test]"
```

### Run Tests

```bash
# Run unit tests
pytest

# Run with coverage
pytest --cov=suno_cli

# Run integration tests (requires API token)
pytest tests/test_integration.py -m integration
```

### Code Quality

```bash
# Format code
ruff format .

# Lint code
ruff check .

# Type check
mypy suno_cli
```

### Build & Publish

```bash
# Install build dependencies
pip install -e ".[release]"

# Build package
python -m build

# Upload to PyPI
twine upload dist/*
```

## Docker

```bash
# Pull the image
docker pull ghcr.io/acedatacloud/suno-cli:latest

# Run a command
docker run --rm -e ACEDATACLOUD_API_TOKEN=your_token \
  ghcr.io/acedatacloud/suno-cli generate "A happy song"

# Or use docker-compose
docker compose run --rm suno-cli generate "A happy song"
```

## Project Structure

```
SunoCli/
├── suno_cli/               # Main package
│   ├── __init__.py
│   ├── __main__.py        # python -m suno_cli entry point
│   ├── main.py            # CLI entry point
│   ├── core/              # Core modules
│   │   ├── client.py      # HTTP client for Suno API
│   │   ├── config.py      # Configuration management
│   │   ├── exceptions.py  # Custom exceptions
│   │   └── output.py      # Rich terminal formatting
│   └── commands/          # CLI command groups
│       ├── generate.py    # Music generation commands (12 commands)
│       ├── lyrics.py      # Lyrics & style commands
│       ├── media.py       # Media conversion commands
│       ├── persona.py     # Persona & upload commands
│       ├── task.py        # Task management commands
│       └── info.py        # Info & utility commands
├── tests/                  # Test suite (80+ tests)
├── .github/workflows/      # CI/CD (lint, test, publish to PyPI)
├── Dockerfile             # Container image
├── deploy/                # Kubernetes deployment configs
├── .env.example           # Environment template
├── pyproject.toml         # Project configuration
└── README.md
```

## Suno CLI vs MCP Suno

| Feature | Suno CLI | MCP Suno |
|---------|----------|----------|
| Interface | Terminal commands | MCP protocol |
| Usage | Direct shell, scripts, CI/CD | Claude, VS Code, MCP clients |
| Output | Rich tables / JSON | Structured MCP responses |
| Automation | Shell scripts, piping | AI agent workflows |
| Install | `pip install suno-cli` | `pip install mcp-suno` |

Both tools use the same AceDataCloud API and share the same API token.

## API Reference

This tool wraps the [AceDataCloud Suno API](https://platform.acedata.cloud/documents/4da95d9d-7722-4a72-857d-bf6be86036e9?utm_source=opensource&utm_medium=referral&utm_campaign=evergreen):

- [Suno Audios API](https://platform.acedata.cloud/documents/4da95d9d-7722-4a72-857d-bf6be86036e9?utm_source=opensource&utm_medium=referral&utm_campaign=evergreen) — Music generation
- [Suno Lyrics API](https://platform.acedata.cloud/documents/514d82dc-f7ab-4638-9f21-8b9275916b08?utm_source=opensource&utm_medium=referral&utm_campaign=evergreen) — Lyrics generation
- [Suno Tasks API](https://platform.acedata.cloud/documents/b0dd9823-0e01-4c75-af83-5a6e2e05bfed?utm_source=opensource&utm_medium=referral&utm_campaign=evergreen) — Task queries
- [Suno Persona API](https://platform.acedata.cloud/documents/78bb6c62-6ce0-490f-a7df-e89d80ec0583?utm_source=opensource&utm_medium=referral&utm_campaign=evergreen) — Persona management

## Contributing

Contributions are welcome! Please:

1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing`)
3. Commit your changes (`git commit -m 'Add amazing feature'`)
4. Push to the branch (`git push origin feature/amazing`)
5. Open a Pull Request

## License

MIT License - see [LICENSE](LICENSE) for details.

## Links

- [AceDataCloud Platform](https://platform.acedata.cloud/?utm_source=opensource&utm_medium=referral&utm_campaign=evergreen)
- [MCP Suno](https://github.com/AceDataCloud/SunoMCP) — MCP server version
- [Suno Official](https://suno.ai/)

---

Made with ❤️ by [AceDataCloud](https://platform.acedata.cloud/?utm_source=opensource&utm_medium=referral&utm_campaign=evergreen)
