Enterprise SDK inside.
Developer experience outside.
JSON only. 🗿

How to change the Base URL in TGCore

You can point TGCore to your own backend by overriding the client base_url:

from tgcore import Client

tg = Client() # reads TGCORE_API_KEY from env (or pass api_key="fw_live_xxx")
tg.base_url = "https://example.com"

return await tg.telegram.getme()

Architecture (enterprise flow)
Backend example: FastAPI
Bot token > API key > AES-256-GCM
encryption > Webhook delivery

Extras (optional):
• Your own web dashboard (account / key management / bot token save)
• Proxy support (safer routing / restricted networks)
• Enterprise controls based on your security needs

Telegram Bot API reference: https://core.telegram.org/bots/api

Default TGCore endpoint: /api/v2/{method}

Source: https://github.com/TeamKillerX/tgcore

Legends use APIs.
Sigma devs write them.

Copas itu kalau ga ngerti.
Reverse engineering itu kalau ngerti terlalu dalam.

ev from tgcore import KeyboardBuilder


await tg.raw.sendPhoto(chat_id=m.chat.id, photo="https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQK7sWBUqrQ7QM1Wr6r-ii3ZhiPKByXA3N4oExb_hWvLQ&s=10", caption="oke mantap", reply_markup=(KeyboardBuilder().copy_text("one ngoding", "oke mantap").build())).execute()

What is TGCore?
TGCore is an official Telegram SDK framework designed for developers to build and integrate Telegram functionalities into their applications.

Can TGCore connect to other platforms?
Yes, TGCore can be used for monitoring and integration purposes, allowing it to connect with other platforms like WhatsApp or Discord.

How does it handle security?
It uses an API key system to prevent bot token leakage and includes web-based developer tools.

Where can I find technical comparisons?
For a detailed technical comparison with the native Telegram API, please refer to the project's GitHub page. Unfortunately, the specific comparison link you provided cannot be accessed at this moment, but you can find the information by visiting the main repository directly.

- Tgcore on Github • Docs

commit log gw bukan history
itu timeline evolusi.🗿

New Features:
Add new endpoint: /api/v2/sendPhoto/upload
Add: tg._post()
Add: tg._get()
Add: tg.set_header()

from tgcore import Client, KeyboardBuilder

tg = Client()

# URL/file_id
await tg.raw.sendPhoto(
  chat_id=m.chat.id,
  photo="https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQK7sWBUqrQ7QM1Wr6r-ii3ZhiPKByXA3N4oExb_hWvLQ&s=10",
  caption="ok",
  reply_markup=(
    KeyboardBuilder()
    .copy_text("This Copy", "ok")
    .build()
  )
).execute()

# Upload file
with open("new_image.jpg", "rb") as f:
    await tg._post("/api/v2/sendPhoto/upload", {
        "chat_id": m.chat.id,
        "photo": ("a.jpg", f, "image/jpeg"),
        "caption": "ok",
        "reply_markup": KeyboardBuilder().url("testing", "https://github.com/TeamKillerX/tgcore").build()
    })

Pypi: https://pypi.org/project/tgcore/

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.