ev import requests, os
from tgcore import KeyboardBuilder

URL = "https://docs-api.dev.ryzenths.dpdns.org/api/v1/flux/black-forest-labs/flux-1-schnell"
h = URL.split("://")[1].split(".")

ok = requests.get(
URL,
params={"query": "Create image a tgcore SDK logo for Telegram."},
headers={"x-api-key": os.getenv("RYZENTH_API_KEY")}
).content

file_name = "new_image.jpg"
with open(file_name, "wb") as f:
f.write(ok)

with open(file_name, "rb") as f:
await tg.raw.sendPhotoUpload(
chat_id=m.chat.id,
caption="Generated Images",
photo=(file_name, f),
reply_markup=(
KeyboardBuilder()
.url(
"Home",
f"https://services-pro.{h[2]}.{h[3]}.{h[4].split('/')[0]}"
)
.row()
.url(
"Docs",
f"https://services-pro.{h[2]}.{h[3]}.{h[4].split('/')[0]}/api/v2/docs"
)
.build()
)
).execute()

Generated Images

Tgcore vs Pyrogram code comparison:

While others use frameworks…
you ship your own.

⚡ tgcore

await tg.raw.sendMessage(
    chat_id=chat_id,
    text=text,
    parse_mode="HTML",
    reply_markup=(
        KeyboardBuilder()
        .url("Github", "https://github.com")
        .build()
    ),
    link_preview_options=(
        LinkPreviewBuilder()
        .is_disabled(True)
        .build()
    )
).execute()

Style: SDK / builder / chainable
Features: flexible, modular, enterprise-ready

🤖 Pyrogram

await app.send_message(
    chat_id=chat_id,
    text=text,
    parse_mode=ParseMode.HTML,
    reply_markup=InlineKeyboardMarkup([
        [InlineKeyboardButton("Github", url="https://github.com")]
    ]),
    link_preview_options=LinkPreviewOptions(
        is_disabled=True
    )
)

Style: framework call
Features: direct delivery, simple, fast to use

Super Short Summary
tgcore: SDK style (flexible)
Pyrogram: Framework style (simple)

Services Pro API Enterprise Stack

Includes
Backend: TypeScript & Python
Frontend: Web interface
Databases: MongoDB, Redis
Webhooks: Telegram & GitHub
Core Engine: tgcore (open source)

Why is Services Pro expensive?

Because it is designed for enterprise-grade performance, scalability, and reliability, not for hobby projects.

If you have to ask the price, it's not for you.

Short version comparison:

tgcore

from tgcore import ChatPermissions as ChatPermissionsBuilder

await tg.raw.setChatPermissions(
    chat_id=message.chat.id,
    permissions=(
        ChatPermissionsBuilder()
        .can_send_messages(False)
        .build()
    )
).execute()

Pyrogram

from pyrogram.types import ChatPermissions

await app.set_chat_permissions(
    permissions=ChatPermissions(
        can_send_messages=False
    )
)

Builder control vs direct call same result, different philosophy.

Example #1: https://github.com/TeamKillerX/tgcore/blob/main/examples/setChatPermissions.py

Source: examples/fastapi-tgcore.py

https://fastapi.tiangolo.com/#example

~ You never read the docs

While they talk,
I merge.

tgcore Ecosystem

TypeScript SDK: https://github.com/TeamKillerX/tgcore-ts

Python SDK: https://github.com/TeamKillerX/tgcore

One engine. Two languages.

https://github.com/TeamKillerX/tgcore-ts

import { Client, KeyboardBuilder } from "@xtsea/tgcore-ts"

const tg = new Client({ api_key: process.env.SERVICES_API_KEY! })

const kb = KeyboardBuilder
  .inline()
  .maxPerRow(1)
  .url("Home", "https://services-pro.ryzenths.dpdns.org")

await tg.calls
  .sendMessage()
  .chatId(-1001234567890)
  .text("<b>Hello World</b>")
  .parseMode("HTML")
  .replyMarkup(kb.build())
  .execute()

Works Anywhere
✅ Backend (Node.js, Next.js API, Express)
✅ Frontend server actions
✅ Serverless (Vercel, Cloudflare, etc.)

🚨 Security Tip:
Never expose or log raw bot tokens like: https://api.telegram.org/bot<TOKEN>

Use:
API key
Webhook
Encrypted backend routing

tgcore = secure abstraction layer over Telegram API.

Clean safe ready for enterprise

If your bot token lives in frontend,
it’s not a feature. It’s a vulnerability.

🏆 Top TGCore Engine
A secure, enterprise-grade middleware layer for Telegram bot development, designed to prevent token leaks and enforce API-key authentication.

• TypeScript: @xtsea/tgcore-ts on npm
• Python: tgcore on PyPI

🥈 Userbot-Auth (UBT)
Authentication library for userbots.
• Python: userbot-auth on PyPI

⏳ Ryzenth UBT Userbot
A full-featured userbot built on these technologies. Release scheduled for 2027. Thank you for your patience.

import { Client } from "@xtsea/tgcore-ts"

// ❌ Don't do this.
// tgcore is not meant to hit api.telegram.org directly.
// Default endpoint is /v2/{method}, not /{method}.
// Also won’t work properly if your server IP is blocked by Telegram
// or you're not using a proxy / webhook.

const tg = new Client({
  api_key: "api_key",
  base_url: `https://api.telegram.org/${bot_token}` // wrong usage
})

✅ Proper flow:
1. Register on Services Pro
2. Add your bot token once in the dashboard
3. Webhook is configured automatically
4. Your bot token never touches your frontend
5. All calls go through:

https://services-pro.ryzenths.dpdns.org/api/v2/{method}

You can still use:
- Pyrogram (MTProto style)
- FastAPI (if you want full control, but heavier)
- Or plain bot API

But tgcore is built as a secure middleware layer, not a raw Telegram proxy.

#1

#2

#3

#4

Final

Evolusi itu pilihan.

https://t.me/c/1558215042/3856