1.0.31

1MinAI-API

An unofficial async Python client for the 1min.AI web interface.

Disclaimer: This library reverse-engineers the 1min.AI browser API. It is not affiliated with or endorsed by 1min.AI. Use responsibly.

---

Features

• Multi-turn conversations — stateful ChatSession keeps context across turns automatically
• Streaming — yield tokens in real time via Server-Sent Events
• Web search grounding — live data, toggleable per-session or per-request
• 30+ chat models — GPT, Claude, Gemini, Grok, DeepSeek, Llama, Mistral, Qwen, and more
• Image generation — Flux, DALL-E, GPT-Image, Gemini, Grok, Stable Diffusion, Recraft, Leonardo, and more
• Image editing — upscale, background removal/replacement, inpainting, variations, face swap, sketch-to-image, 3D, object removal, text removal, outpainting
• Text to speech — OpenAI TTS and ElevenLabs
• Speech to text — Whisper, GPT-4o Transcribe, ElevenLabs, Google STT
• Voice tools — isolate, clone, change, and design voices; generate sound effects
• Video generation — Kling, Sora, Veo, Luma Ray, Wan, and more; text-to-video and image-to-video
• Music generation — Google Lyria, Suno, Udio, MusicGen
• Code generation — GPT Codex, Qwen3 Coder, Grok Code, DeepSeek Coder, Claude
• Content tools — grammar, paraphrase, rewrite, summarise, expand, shorten, translate, blog/email/social/ad copy, YouTube tools, document translation
• Asset API — upload local files or public URLs (images, PDFs, audio, video) for use across all endpoints
• Conversation management — create, list, fetch history, and delete server-side threads
• Credit estimation — pre-flight cost check before sending a request
• Async-first — built on aiohttp, zero blocking calls

---

Related projects

ChatAI Console

A full-featured self-hosted web UI that supports Claude, ChatWithAI.app, and 1min.AI accounts.

Features:

• Multi-account management — Claude, ChatWithAI.app, and 1min.AI accounts in one place
• Real-time streaming with artifact rendering
• File upload and canvas preview panel
• Google OAuth sign-in flow
• Credit tracking and usage history
• Local conversation storage with pinning

---

Installation

Requires Python 3.10+.

pip install oneminai-webapi

---

Authentication

API key

1. Sign in at app.1min.ai.
2. Go to Settings → API and copy your key.
3. Pass it to OneMinAIClient.

client = OneMinAIClient("YOUR_API_KEY")

Store it in an environment variable rather than hardcoding it:

import os
client = OneMinAIClient(os.environ["ONEMINAI_API_KEY"])

Keep your key secret — it grants full access to your 1min.AI account and credits.

OAuth (Google access token)

If you already have a Google OAuth2 access token (ya29.…) — for example obtained via a browser extension — pass it directly:

client = OneMinAIClient()
user = await client.oauth_login("ya29.a0AQvPy…")
# all subsequent calls are authenticated automatically

The JWT returned by 1min.AI is stored internally. No API key is needed when using this flow.

---

Quick start

import asyncio
from oneminai_webapi import OneMinAIClient

async def main():
    async with OneMinAIClient("YOUR_API_KEY") as client:
        r = await client.generate_content("What is the capital of Poland?")
        print(r.text)   # "Warsaw"

asyncio.run(main())

The async with block closes the underlying HTTP session automatically. For manual lifecycle management:

client = OneMinAIClient("YOUR_API_KEY")
try:
    r = await client.generate_content("Hello!")
    print(r.text)
finally:
    await client.close()

---

Usage

Single-turn generation

r = await client.generate_content("Translate 'hello' to Japanese.")
print(r.text)    # "こんにちは"
print(r.model)   # "gpt-4.1-nano"
print(str(r))    # same as r.text

Attach images or documents:

asset = await client.upload_asset("chart.png")
r = await client.generate_content(
    "Describe what you see in this chart.",
    images=[asset.asset_key],
)

doc = await client.upload_asset("report.pdf")
r2 = await client.generate_content(
    "Summarise this document.",
    files=[doc.file_id],
)

---

Streaming

async for chunk in client.generate_content_stream("Write me a haiku."):
    print(chunk.text_delta, end="", flush=True)
print()

---

Multi-turn chat

start_chat() returns a ChatSession that tracks context automatically:

chat = client.start_chat()

r1 = await chat.send_message("My name is Alice.")
r2 = await chat.send_message("What is my name?")   # → "Your name is Alice."
print(r2.text)

Streaming within a session:

async for chunk in chat.send_message_stream("Write a short poem about it."):
    print(chunk.text_delta, end="", flush=True)
print()

# Context persists across streaming and non-streaming turns
r3 = await chat.send_message("Now explain it line by line.")

---

Web search

# Enable for every turn in the session
chat = client.start_chat(web_search=True, num_of_site=5)
r = await chat.send_message("What AI models were released this week?")

# Or enable per-request only
chat2 = client.start_chat()
r2 = await chat2.send_message("Latest Python release?", web_search=True)

---

Model selection

from oneminai_webapi.constants import ChatModel

# Via enum
r = await client.generate_content("Hello!", model=ChatModel.CLAUDE_SONNET_4_6)

# Via raw string — any model ID from the catalog works
r2 = await client.generate_content("Hello!", model="gemini-2.5-flash")

# Session-level default
chat = client.start_chat(model=ChatModel.GPT_4O)

Available chat models (partial list — use list_models() for the full live catalog):

---

Persistent server-side conversations

# Create a named thread
conv = await client.create_conversation("Research session")

# Chat within it — history is stored server-side
r = await client.chat(
    "What is quantum entanglement?",
    conversation_id=conv.conversation_id,
)

# Fetch full message history
messages = await client.get_conversation_messages(conv.conversation_id)
for msg in messages:
    print(f"[{msg.role}]: {msg.content}")

# List all threads
all_convs = await client.list_conversations()

# Delete when done
await client.delete_conversation(conv.conversation_id)

---

Image generation

from oneminai_webapi.constants import ImageModel

result = await client.generate_image(
    "A serene mountain lake at golden hour, photorealistic",
    model=ImageModel.FLUX_1_1_PRO,
    width=1024,
    height=1024,
    num_images=2,
)

print(result.image.url)          # first image URL
for img in result.images:
    await img.save("./outputs")  # download all to disk

---

Image editing

asset = await client.upload_asset("photo.jpg")

upscaled  = await client.upscale_image(asset.asset_key, scale=2)
no_bg     = await client.remove_background(asset.asset_key)
new_bg    = await client.replace_background(asset.asset_key, "A sunny beach at sunset")
edited    = await client.edit_image(asset.asset_key, "Make the sky purple")
inpainted = await client.inpaint_image(asset.asset_key, mask.asset_key, "A red rose")
extended  = await client.extend_image(asset.asset_key, direction="right")
variants  = await client.create_image_variation(asset.asset_key, num_images=4)
swapped   = await client.swap_face(face_img.asset_key, target_img.asset_key)
rendered  = await client.sketch_to_image(sketch.asset_key, "A cozy cottage")
model_3d  = await client.image_to_3d(asset.asset_key)
clean     = await client.remove_text_from_image(asset.asset_key)
replaced  = await client.search_and_replace_in_image(asset.asset_key, "red car", "blue bicycle")

prompt    = await client.image_to_prompt(asset.asset_key)
print(prompt.text)

---

Text to speech

from oneminai_webapi.constants import TTSModel, TTSVoice

audio = await client.text_to_speech(
    "Hello, this is a test.",
    model=TTSModel.OPENAI_TTS_1_HD,
    voice=TTSVoice.NOVA,
    speed=1.0,
)
await audio.save("./outputs", verbose=True)

# ElevenLabs — pass voice name as a plain string
el = await client.text_to_speech(
    "Sounds natural.",
    model=TTSModel.ELEVENLABS,
    voice="Rachel",
)

# Sound effects
sfx = await client.text_to_sound(
    "Heavy rain on a tin roof, distant thunder",
    duration=10.0,
)

---

Speech to text

from oneminai_webapi.constants import STTModel

asset = await client.upload_asset("recording.mp3")

result    = await client.speech_to_text(asset.asset_key, model=STTModel.WHISPER_1)
print(result.text)

translated = await client.translate_audio(asset.asset_key, "English")
captions   = await client.generate_captions(asset.asset_key)

---

Voice tools

clean    = await client.isolate_voice(audio.asset_key)
changed  = await client.change_voice(audio.asset_key, target_voice="Josh")
cloned   = await client.clone_voice(audio.asset_key, name="MyVoice")
designed = await client.design_voice(
    "A calm, middle-aged British woman with a warm tone",
    sample_text="Hello, how can I help you today?",
)

---

Video generation

from oneminai_webapi.constants import VideoModel

video = await client.generate_video(
    "Drone shot rising over snow-capped mountains at dawn",
    model=VideoModel.KLING,
    duration=5,
    aspect_ratio="16:9",
)
await video.save("./outputs")

asset = await client.upload_asset("frame.jpg")
vid2  = await client.image_to_video(
    asset.asset_key,
    prompt="Camera slowly pans left, leaves gently swaying",
    model=VideoModel.LUMA,
)

swapped = await client.swap_face_in_video(video.video_url, face_img.asset_key)

---

Music generation

from oneminai_webapi.constants import MusicModel

track = await client.generate_music(
    "Upbeat lo-fi hip hop, 90 BPM, warm piano chords",
    model=MusicModel.LYRIA_2,
)
await track.save("./outputs")

score = await client.generate_music(
    "Epic cinematic orchestral, building tension",
    instrumental=True,
    duration=30.0,
)

---

Code generation

from oneminai_webapi.constants import CodeModel

result = await client.generate_code(
    "Async HTTP client with exponential-backoff retry using aiohttp.",
    model=CodeModel.CLAUDE_SONNET_4_6,
)
print(result.text)

# With live web search to reference latest docs
result2 = await client.generate_code(
    "FastAPI endpoint validating JWT with PyJWT 2.x.",
    web_search=True,
)

---

Content tools

# Text editing
corrected   = await client.check_grammar("its a beautifull day!")
paraphrased = await client.paraphrase("Text to rewrite.", tone="casual")
rewritten   = await client.rewrite("Formal text.", tone="friendly")
summary     = await client.summarize(long_article)
expanded    = await client.expand_content("Short stub.")
shortened   = await client.shorten_content(verbose_text)

# Translation & detection
polish      = await client.translate("Good morning", "Polish")
detection   = await client.detect_ai_content(suspicious_text)

# SEO
keywords    = await client.research_keywords("async Python AI")

# Content generation
article     = await client.generate_blog_article("AI trends in 2025")
email       = await client.generate_email("Partnership proposal to Acme Corp")
reply       = await client.generate_email_reply(original_email, "Accept politely")
tweet       = await client.generate_social_post("Launch day!", platform="x")
linkedin    = await client.generate_social_post("We shipped v1!", platform="linkedin")
fb_ad       = await client.generate_ad_copy("Fast async Python SDK", platform="facebook")
slides      = await client.generate_presentation("The future of AI in 2026")

# YouTube
yt_summary  = await client.summarize_youtube("https://youtu.be/dQw4w9WgXcQ")
yt_script   = await client.transcribe_youtube("https://youtu.be/dQw4w9WgXcQ")
yt_polish   = await client.translate_youtube("https://youtu.be/dQw4w9WgXcQ", "Polish")

# Document translation
doc         = await client.upload_asset("contract.pdf")
translated  = await client.translate_document(doc.file_id, "Spanish")

---

Asset upload

import oneminai_webapi

# Local file
asset = await client.upload_asset(
    "report.pdf",
    asset_type=oneminai_webapi.AssetType.DOCUMENT,
)

# Raw bytes
asset2 = await client.upload_asset(
    data=some_bytes,
    filename="image.png",
    mime_type="image/png",
    asset_type=oneminai_webapi.AssetType.IMAGE,
)

# Public URL
asset3 = await client.upload_asset_from_url("https://example.com/photo.jpg")

# Use in chat
reply = await client.generate_content(
    "Summarise this document.",
    files=[asset.file_id],      # file_id for documents in chat
)

# Use in image APIs
upscaled = await client.upscale_image(asset2.asset_key)  # asset_key for media

AssetRecord fields:

---

Account & credits

user = await client.get_current_user()
print(user.email, user.plan, user.credit)

balance = await client.get_team_credits()

estimate = await client.estimate_chat_cost(
    "Write a long essay about quantum computing.",
    models=["gpt-4o", "claude-sonnet-4-6"],
    web_search=True,
)
print(f"Estimated: {estimate.total_estimated_credit} credits")

models = await client.list_models(feature="UNIFY_CHAT_WITH_AI")

---

Logging

import oneminai_webapi
oneminai_webapi.set_log_level("DEBUG")   # DEBUG | INFO | WARNING | ERROR

---

Error handling

from oneminai_webapi.exceptions import (
    AuthenticationError,   # 401 — invalid or missing API key / token
    RateLimitError,        # 429 — too many requests
    ValidationError,       # 422 — bad request payload
    APIError,              # any other 4xx / 5xx
    AssetUploadError,      # file upload failed
    OAuthError,            # OAuth login failed
)

try:
    r = await client.generate_content("Hello!")
except AuthenticationError:
    print("Invalid API key.")
except RateLimitError as e:
    print(f"Rate limited — retry in {e.retry_after_s}s")
except ValidationError as e:
    print(f"Validation error: {e.details}")
except APIError as e:
    print(f"API error {e.status_code}: {e}")

---

API reference

OneMinAIClient

Chat

Conversations

Images

Audio

Video

Music

Code & content

Assets

Account

---

ChatSession

---

Return types

---

Development

git clone https://github.com/cyber-wojtek/1MinAI-API
cd 1MinAI-API
pip install -e ".[dev]"

export ONEMINAI_API_KEY="your-key"
python examples.py

---

References

• 1min.AI
• 1min.AI app
• claude-webapi — sister project for Claude.ai
• gemini_webapi — inspiration for the interface design