DEV Community: Zaenal Arifin

🚀 Panduan Hosting Website di Raspberry Pi + Subdomain

Zaenal Arifin — Fri, 12 Dec 2025 03:24:51 +0000

Panduan ini buat bikin Website online di Raspberry Pi dengan FastAPI + Gunicorn + Uvicorn + Nginx + SSL, sekaligus atur subdomain supaya bisa diakses dari internet.

1️⃣ Update & Install Dependency

sudo apt update && sudo apt upgrade -y
sudo apt install python3-pip python3-venv nginx git -y

2️⃣ Clone Project

Catatan:

Ganti username/project.git sesuai repository GitHub kamu
Path folder lokal (cd project) bisa diganti sesuai nama project
Pilih metode dependency sesuai kebutuhan: Poetry atau requirements.txt

git clone https://github.com/username/project.git   # <-- ganti URL repo kamu
cd project                                          # <-- ganti sesuai nama folder project

Kalau pakai Poetry:

sudo pip install poetry
poetry install                                     # <-- otomatis install dependency dari pyproject.toml

Kalau pakai requirements.txt:

python3 -m venv venv                               # <-- buat virtual environment
source venv/bin/activate                            # <-- aktifkan venv
pip install -r requirements.txt                    # <-- install dependency dari requirements.txt

💡 Tips:

Pastikan branch yang ingin dijalankan sesuai kebutuhan (git checkout branch-name)

Kalau pakai Poetry, pastikan poetry shell atau jalankan dengan .venv/bin/python sesuai virtual environment

3️⃣ Test FastAPI Lokal

gunicorn main:app --workers 4 --worker-class uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000

Buka browser http://127.0.0.1:8000 harus muncul website.

4️⃣ Setup systemd Service

Biar FastAPI jalan otomatis di background. Catatan: ganti semua bagian yang sesuai project kamu, khususnya:

project.service → nama service, bisa diganti sesuai project
User & Group → user di Pi yang punya akses ke folder project
WorkingDirectory → path ke folder project di Pi
ExecStart → path ke virtual environment dan nama file app (main:app)

sudo vim /etc/systemd/system/project.service

Isi file (sesuaikan nama & path):

# /etc/systemd/system/project.service
[Unit]
Description=project FastAPI
After=network.target

[Service]
User=pi
Group=pi
WorkingDirectory=/home/pi/project
Environment="PATH=/home/pi/project/myenv/bin"
ExecStart=/home/pi/project/project/myenv/bin/gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000
Restart=always
RestartSec=5s

[Install]
WantedBy=multi-user.target

Enable & start service:

sudo systemctl daemon-reload
sudo systemctl enable project        # <-- pastikan sama dengan nama file service
sudo systemctl start project
sudo systemctl status project

💡 Note:

Nama service (project) harus konsisten di /etc/systemd/system/ dan saat enable/start

Path WorkingDirectory dan ExecStart harus sesuai lokasi project & virtual environment kamu

Jika pakai Poetry, path ke executable bisa diganti: /home/pi/project/.venv/bin/gunicorn ...

5️⃣ Setup Nginx sebagai Reverse Proxy

Catatan: ganti semua yang perlu sesuai project kamu, khususnya:

project.conf → nama file config, bisa sesuai project
server_name → subdomain / domain yang kamu pakai
proxy_pass → URL lokal tempat FastAPI/Gunicorn berjalan

sudo vim /etc/nginx/sites-available/project.conf

Isi file (sesuaikan nama & domain):

server {
    listen 80;
    server_name project.example.com;   # <-- ganti sesuai subdomain / domain kamu

    location / {
        proxy_pass http://127.0.0.1:8000;   # <-- ganti port sesuai Gunicorn
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Enable config & restart Nginx:

sudo ln -s /etc/nginx/sites-available/project.conf /etc/nginx/sites-enabled/
sudo nginx -t                     # <-- cek syntax
sudo systemctl restart nginx      # <-- restart Nginx supaya config berlaku

💡 Note:

Nama file config (project.conf) bisa diganti sesuai project, tapi harus konsisten saat ln -s

server_name harus sama dengan subdomain / domain yang sudah diarahkan di DNS

proxy_pass harus sesuai port Gunicorn/Uvicorn yang kamu pakai

6️⃣ Pasang SSL Gratis dengan Let’s Encrypt

Catatan: ganti project.example.com dengan subdomain atau domain yang sudah diarahkan ke server kamu.

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d project.example.com   # <-- ganti sesuai domain/subdomain kamu

💡 Tips & Catatan:

Ikuti instruksi di layar untuk verifikasi domain dan otomatis konfigurasi HTTPS.

Setelah selesai, Certbot akan otomatis men-setup redirect HTTP → HTTPS.

Untuk perpanjangan SSL otomatis, Certbot biasanya sudah menambahkan cron job. Bisa cek dengan:
  sudo systemctl status certbot.timer
Pastikan domain/subdomain sudah propagasi di DNS sebelum menjalankan Certbot.

7️⃣ Opsi Subdomain

Catatan Umum:

Ganti project atau project.example.com sesuai nama project/subdomain kamu

Pastikan DNS domain/subdomain sudah diarahkan ke server atau tunnel sebelum testing

Pilih opsi sesuai kondisi IP server: statik atau dinamis

Opsi 1 – Arahkan langsung ke IP publik

Kalau server punya IP publik statik (atau pakai Dynamic DNS):

Login ke Cloudflare → pilih domain → DNS.
Tambah A record:

Name: project # <-- ganti sesuai subdomain
Type: A
Content: IP publik Raspberry Pi # <-- ganti sesuai IP server
Proxy status: Proxied / DNS only
1. Port forwarding di router (kalau ada):
Port 80 → Raspberry Pi
Port 443 → Raspberry Pi

Kelebihan: Cepat, langsung, bisa pakai Nginx & SSL
Kekurangan: Kalau IP publik berubah (dynamic IP), subdomain putus

Opsi 2 – Pakai Cloudflare Tunnel (Argo Tunnel)

Cocok kalau server IP dinamis atau di belakang NAT.

Install cloudflared:

sudo apt install curl -y
curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-arm64.deb -o cloudflared.deb
sudo dpkg -i cloudflared.deb

cloudflared tunnel login
cloudflared tunnel create project-tunnel   # <-- ganti nama tunnel sesuai project

Hubungkan subdomain:

cloudflared tunnel route dns project.example.com project-tunnel   # <-- ganti domain/subdomain

Jalankan tunnel:

cloudflared tunnel run project-tunnel

Kelebihan: Tidak perlu port forwarding, aman, HTTPS otomatis
Kekurangan: Harus jalankan tunnel di background atau sebagai systemd service

💡 Tips:

Bisa buat systemd service untuk tunnel supaya otomatis jalan tiap boot

Pastikan subdomain sudah terpropagasi di DNS sebelum menjalankan tunnel

Biar cloudflared tunnel jalan otomatis TANPA kamu harus ngetik:

cloudflared tunnel run project-tunnel

Setiap kali boot Raspberry Pi, kamu harus bikin service systemd khusus untuk Cloudflare Tunnel.

Langsung aja—ini cara paling rapi & benar:

✅ 1. Buat file service systemd

sudo vim /etc/systemd/system/cloudflared.service

Isi file:

[Unit]
Description=Cloudflare Tunnel
After=network-online.target
Wants=network-online.target

[Service]
User=pi
Group=pi
ExecStart=/usr/bin/cloudflared tunnel run project-tunnel
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Catatan penting:

project-tunnel → sesuaikan dengan nama tunnel kamu cek dengan:
  cloudflared tunnel list
Lokasi cloudflared biasanya /usr/bin/cloudflared. Cek dengan:
  which cloudflared

✅ 2. Reload systemd dan aktifkan service

sudo systemctl daemon-reload
sudo systemctl enable cloudflared
sudo systemctl start cloudflared
sudo systemctl status cloudflared

Kalau tampilannya active (running) berarti sukses.

📌 3. Cek apakah tunnel sudah jalan

cloudflared tunnel list

Harusnya status-nya HEALTHY.

🎉 Setelah ini:

✔ Cloudflare Tunnel otomatis hidup setelah reboot
✔ Kamu tidak perlu manual run lagi
✔ Website aman tanpa port forwarding

✅ Selesai!
Website kamu sekarang online di subdomain, dan service FastAPI + Gunicorn berjalan otomatis tiap boot.

🚀 Multichain Crypto API — Full Endpoint Overview

Zaenal Arifin — Wed, 10 Dec 2025 04:57:09 +0000

The Multichain Crypto API is a powerful, developer-friendly solution that allows you to easily interact with multiple blockchains without running your own nodes. With ready-to-use endpoints, you can check wallet balances, send tokens across chains, estimate gas fees, simulate token swaps, monitor transactions, and more. Perfect for dashboards, trading bots, multi-chain wallets, and automated crypto systems. 🎉

🚀 Explore & Subscribe: RapidAPI – Multichain Crypto API
📖 Full Documentation: API Docs
🛠️ Interactive API Reference: Redoc / Swagger UI

🔧 API Setup

Base URL: https://multichain-crypto-api4.p.rapidapi.com
Authentication: RapidAPI Key (X-RapidAPI-Key)
Supported chains: Solana, Ethereum, BSC, TRON, Polygon, Base, and more
Supported tokens: See full list at /api/v1/crypto/tokens

Pro Tip: Use the /api/v1/crypto/tokens endpoint to dynamically fetch supported tokens for your dashboard or trading bot.

📚 Endpoints Overview

Endpoint	Method	Description
`/api/v1/crypto/ping`	GET	Ping the API to check if it’s alive
`/api/v1/crypto/send/native`	POST	Send native tokens (SOL, ETH, BNB, TRON, MATIC, BASE)
`/api/v1/crypto/send/usdc`	POST	Send USDC tokens across supported chains
`/api/v1/crypto/send/usdt`	POST	Send USDT tokens across supported chains
`/api/v1/crypto/balance`	GET	Get wallet balance for a specific chain
`/api/v1/crypto/price`	GET	Get the current price of a token
`/api/v1/crypto/estimate-gas`	GET	Estimate gas fee for transactions on EVM chains
`/api/v1/crypto/tokens`	GET	List all tokens supported by the API
`/api/v1/crypto/swap/simulasi`	POST	Simulate token swaps to check expected output
`/api/v1/crypto/token_info`	GET	Get metadata for a token (name, symbol, decimals, contract address)
`/api/v1/crypto/tx_status`	GET	Check status of a transaction by its hash

SEO Tip: Each endpoint name and description includes target keywords like send tokens, check wallet balance, estimate gas.

📚 Available Endpoints with CURL Examples & Quick Tutorials

1️⃣ Ping API

GET /api/v1/crypto/ping
Check if the API is running and responsive.

Note: Replace <YOUR_API_KEY> with your RapidAPI Key. All curl examples below use the same X-RapidAPI-Key and X-RapidAPI-Host headers.

curl "https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/ping" \
  -H "X-RapidAPI-Key: <YOUR_API_KEY>" \
  -H "X-RapidAPI-Host: multichain-crypto-api4.p.rapidapi.com"

Example response:

{
  "status": "success",
  "message": "API is alive"
}

2️⃣ Send Native Token (SOL, ETH, BNB, TRON, MATIC, BASE)

POST /api/v1/crypto/send/native

Note:

Replace <YOUR_API_KEY> with your RapidAPI Key.

All curl examples use the same X-RapidAPI-Key and X-RapidAPI-Host headers.

Replace <PRIVATE_KEY> with your wallet private key.

curl --request POST \
  --url 'https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/send/native?token=<TOKEN>&destination_wallet=<DESTINATION_WALLET>&amount=<AMOUNT>&rpc_url=<RPC_URL>&private_key=<PRIVATE_KEY>' \
  --header 'Content-Type: application/json' \
  --header 'x-rapidapi-host: multichain-crypto-api4.p.rapidapi.com' \
  --header 'x-rapidapi-key: <YOUR_API_KEY>' \
  --data '{}'

Use case: Send 1 SOL from your admin wallet to any Solana wallet in Devnet or Mainnet without running your own node.

3️⃣ Send USDC or USDT

POST /api/v1/crypto/send/usdc
POST /api/v1/crypto/send/usdt

Note:

Replace <YOUR_API_KEY> with your RapidAPI Key.

All curl examples use the same X-RapidAPI-Key and X-RapidAPI-Host headers.

Replace <PRIVATE_KEY> with your wallet private key.

Replace <TOKEN_ADDRESS>, <CHAIN>, <AMOUNT>, <DESTINATION_WALLET>, and <RPC_URL> with your values.

curl --request POST \
  --url 'https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/send/usdc?private_key=<PRIVATE_KEY>&rpc_url=<RPC_URL>&token_address=<TOKEN_ADDRESS>&chain=<CHAIN>&amount=<AMOUNT>&destination_wallet=<DESTINATION_WALLET>' \
  --header 'Content-Type: application/json' \
  --header 'x-rapidapi-host: multichain-crypto-api4.p.rapidapi.com' \
  --header 'x-rapidapi-key: <YOUR_API_KEY>' \
  --data '{}'

Use case: Send USDC across Ethereum, BSC, Polygon, or Base chains. Perfect for multi-chain wallets or dashboards.

4️⃣ Get Wallet Balance

GET /api/v1/crypto/balance

Note:

Replace <YOUR_API_KEY> with your RapidAPI Key.

All curl examples use the same X-RapidAPI-Key and X-RapidAPI-Host headers.

Replace <CHAIN>, <WALLET_ADDRESS>, and <RPC_URL> with your values.

curl --request GET \
  --url 'https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/balance?chain=<CHAIN>&wallet=<WALLET_ADDRESS>&rpc_url=<RPC_URL>' \
  --header 'x-rapidapi-host: multichain-crypto-api4.p.rapidapi.com' \
  --header 'x-rapidapi-key: <YOUR_API_KEY>'

Example JSON response:

{
  "status": "success",
  "chain": "sol",
  "wallet": "<WALLET_ADDRESS>",
  "balance": 10.5
}

Tip: Combine this with webhooks to monitor wallet balances in real-time.

5️⃣ Get Token Price

GET /api/v1/crypto/price

Note:

Replace <YOUR_API_KEY> with your RapidAPI Key.

All curl examples use the same X-RapidAPI-Key and X-RapidAPI-Host headers.

curl --request GET \
    --url https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/price \
    --header 'x-rapidapi-host: multichain-crypto-api4.p.rapidapi.com' \
    --header 'x-rapidapi-key: <YOUR_API_KEY>'

Perfect for building live dashboards showing token prices across multiple chains.

6️⃣ Estimate Gas Fee

GET /api/v1/crypto/estimate-gas

Note:

Replace <YOUR_API_KEY> with your RapidAPI Key.

All curl examples use the same X-RapidAPI-Key and X-RapidAPI-Host headers.

Replace <CHAIN>, <TOKEN>, <AMOUNT>, and <WALLET_ADDRESS> with your values.

curl --request GET \
  --url 'https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/estimate-gas?chain=<CHAIN>&token=<TOKEN>&amount=<AMOUNT>&destination_wallet=<WALLET_ADDRESS>' \
  --header 'x-rapidapi-host: multichain-crypto-api4.p.rapidapi.com' \
  --header 'x-rapidapi-key: <YOUR_API_KEY>'

Use this to calculate the approximate fee before sending a transaction. Helps prevent failed transfers due to insufficient gas.

7️⃣ Get Supported Tokens

GET /api/v1/crypto/tokens

Note:

Replace <YOUR_API_KEY> with your RapidAPI Key.

All curl examples use the same X-RapidAPI-Key and X-RapidAPI-Host headers.

curl --request GET \
    --url https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/tokens \
    --header 'x-rapidapi-host: multichain-crypto-api4.p.rapidapi.com' \
    --header 'x-rapidapi-key: <YOUR_API_KEY>'

Tip: This endpoint is important for dynamic frontends or dashboards to list all supported tokens across Solana, Ethereum, BSC, TRON, Polygon, Base, and more.

8️⃣ Simulate Token Swap

POST /api/v1/crypto/swap/simulasi

Note:

Replace <YOUR_API_KEY> with your RapidAPI Key.

All curl examples use the same X-RapidAPI-Key and X-RapidAPI-Host headers.

Replace <FROM_TOKEN>, <TO_TOKEN>, and <AMOUNT> with your values.

curl --request POST \
  --url 'https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/swap/simulasi?from_token=<FROM_TOKEN>&to_token=<TO_TOKEN>&amount=<AMOUNT>' \
  --header 'Content-Type: application/json' \
  --header 'x-rapidapi-host: multichain-crypto-api4.p.rapidapi.com' \
  --header 'x-rapidapi-key: <YOUR_API_KEY>' \
  --data '{}'

Simulate swaps before executing real transactions to prevent slippage or unexpected token conversion rates.

9️⃣ Get Token Metadata

GET /api/v1/crypto/token_info

Note:

Replace <YOUR_API_KEY> with your RapidAPI Key.

All curl examples use the same X-RapidAPI-Key and X-RapidAPI-Host headers.

Replace token=sol with the token you want metadata for.

curl --request GET \
    --url 'https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/token_info?token=sol' \
    --header 'x-rapidapi-host: multichain-crypto-api4.p.rapidapi.com' \
    --header 'x-rapidapi-key: <YOUR_API_KEY>'

Retrieve token name, symbol, decimals, and contract address programmatically.

🔟 Get Transaction Status

GET /api/v1/crypto/tx_status

Note:

Replace <YOUR_API_KEY> with your RapidAPI Key.

All curl examples use the same X-RapidAPI-Key and X-RapidAPI-Host headers.

Replace <TX_HASH> and <CHAIN> with your transaction hash and the corresponding chain.

curl --request GET \
  --url 'https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/tx_status?tx_hash=<TX_HASH>&chain=<CHAIN>' \
  --header 'x-rapidapi-host: multichain-crypto-api4.p.rapidapi.com' \
  --header 'x-rapidapi-key: <YOUR_API_KEY>'

Monitor the confirmation status of your transactions across chains.

🔗 Why Use Multichain Crypto API?

Multi-chain support: Solana, Ethereum, BSC, TRON, Polygon, Base, etc.
Unified endpoints for wallets, tokens, and transactions
No need to run your own blockchain nodes
Ready for async automation, trading bots, and dashboards
Fast, developer-friendly, and production-ready
SEO optimized: endpoints, keywords, and example JSON snippets help with search visibility

💡 Pro Tip: Combine this API with webhooks or monitoring scripts to get real-time updates for wallets and transactions.

📄 Full Documentation: API Docs
🧩 Interactive API Reference: Redoc / Swagger UI

Explore all endpoints and subscribe here: RapidAPI – Multichain Crypto API

How to Send Native Crypto Tokens Across Multiple Blockchains Using FastAPI API

Zaenal Arifin — Mon, 08 Dec 2025 03:52:39 +0000

Sending native crypto tokens like SOL, ETH, BNB, or BASE programmatically can be challenging, especially when you need to handle transaction signing, network RPC, and error handling.

The Crypto API Service provides a simple solution via its FastAPI endpoints. In this article, we’ll guide you through sending native tokens using the /send/native endpoint with a Python async example.

1️⃣ Prerequisites

Python 3.11+
Install dependencies:

pip install httpx asyncio

RapidAPI key (subscribe to the Crypto API Service)
Sender wallet private key (for demo; never expose mainnet keys publicly)
Destination wallet address

2️⃣ Understanding the `/send/native` Endpoint

The endpoint /send/native allows you to send native blockchain tokens:

Required parameters:

token: Token symbol (SOL, ETH, BNB, BASE)
destination_wallet: Recipient address
amount: Amount to send
rpc_url: Optional custom RPC URL
private_key: Optional private key for signing the transaction

Response:

{
  "status": "success",
  "tx_hash": "5NfL1yS5kJjKx9rR4v8Q7P1M2Zq3vT6Y",
  "message": "SOL successfully sent"
}

3️⃣ Example Python Script

Create send_native.py:

# send_native.py
import asyncio
import httpx
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

API_URL = "https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/send/native"
API_KEY = "YOUR_RAPIDAPI_KEY"  # replace with your RapidAPI key

async def send_native_token(token: str, destination_wallet: str, amount: float, rpc_url: str = None, private_key: str = None):
    """Send native token via Crypto API"""
    async with httpx.AsyncClient() as client:
        try:
            if amount <= 0:
                raise ValueError("Amount must be greater than 0")

            logger.info(f"🚀 Sending {amount} {token.upper()} to {destination_wallet}")

            resp = await client.post(
                API_URL,
                params={
                    "token": token,
                    "destination_wallet": destination_wallet,
                    "amount": amount,
                    "rpc_url": rpc_url,
                    "private_key": private_key
                },
                headers={"X-RapidAPI-Key": API_KEY}
            )
            resp.raise_for_status()
            data = resp.json()

            if data.get("status") != "success":
                raise Exception(data.get("message", "Transaction failed"))

            logger.info(f"✅ Transaction successful: {data}")
            return data
        except Exception as e:
            logger.error(f"❌ Failed to send token: {e}", exc_info=True)
            return None

async def main():
    token = "SOL"
    destination_wallet = "YourDestinationWalletAddress"
    amount = 0.01
    rpc_url = "https://api.devnet.solana.com"  # optional, can use default
    private_key = "YOUR_PRIVATE_KEY"           # optional, can be None if using API signing

    result = await send_native_token(token, destination_wallet, amount, rpc_url, private_key)
    if result:
        print(f"Transaction Hash: {result.get('tx_hash')}")
        print(f"Status: {result.get('status')}")
        print(f"Message: {result.get('message')}")

if __name__ == "__main__":
    asyncio.run(main())

4️⃣ Example Output

{
  "status": "success",
  "tx_hash": "5NfL1yS5kJjKx9rR4v8Q7P1M2Zq3vT6Y",
  "message": "SOL successfully sent"
}

Console output:

Transaction Hash: 5NfL1yS5kJjKx9rR4v8Q7P1M2Zq3vT6Y
Status: success
Message: SOL successfully sent

5️⃣ How to Run

Save script as send_native.py
Replace YOUR_RAPIDAPI_KEY and YOUR_PRIVATE_KEY (if needed)
Set token, destination wallet, and amount
Run:

python send_native.py

Check console for transaction hash and status

6️⃣ Tips for Safe Token Transfers

Never commit private keys to version control. Use environment variables or secure vaults.
Test on devnet/testnet first before sending mainnet tokens.
Log all responses for debugging and auditing purposes.
Handle exceptions gracefully to avoid lost transactions or crashes.

7️⃣ Closing

Using the /send/native endpoint, you can send SOL, ETH, BNB, or BASE tokens easily without handling low-level blockchain operations. This is ideal for wallet apps, bots, and automated payment systems.

To explore more, you can combine this with balance checking or transaction status monitoring endpoints from the Crypto API Service on RapidAPI.

How to Track Ethereum Transaction Status with FastAPI API

Zaenal Arifin — Mon, 08 Dec 2025 03:49:35 +0000

Tracking Ethereum transaction status can be tricky, especially when you want reliable, real-time updates. Using the Crypto API Service, you can easily check if a transaction is pending, confirmed, or failed.

In this tutorial, we’ll create a Python async script to query the transaction status of an Ethereum transaction using the API.

1️⃣ Setup

Python 3.11+
Install dependencies:

pip install httpx asyncio

RapidAPI key (subscribe to Crypto API Service)

2️⃣ Example Python Script

Create check_eth_tx.py:

# check_eth_tx.py
import asyncio
import httpx
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

API_URL = "hhttps://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/tx_status"
API_KEY = "YOUR_RAPIDAPI_KEY"  # replace with your RapidAPI key

async def get_tx_status(tx_hash: str):
    """Async function to fetch Ethereum transaction status"""
    async with httpx.AsyncClient() as client:
        try:
            resp = await client.get(
                API_URL,
                params={"chain": "eth", "tx_hash": tx_hash},
                headers={"X-RapidAPI-Key": API_KEY}
            )
            resp.raise_for_status()
            data = resp.json()
            logger.info(f"Transaction data: {data}")
            return data
        except httpx.HTTPError as e:
            logger.error(f"Failed to fetch transaction: {e}")
            return None

async def main():
    tx_hash = "0x123abc...your_tx_hash_here"
    tx_data = await get_tx_status(tx_hash)
    if tx_data:
        print(f"Transaction Hash: {tx_data['tx_hash']}")
        print(f"Status: {tx_data['status']}")
        print(f"Message: {tx_data.get('message', '')}")

if __name__ == "__main__":
    asyncio.run(main())

3️⃣ Example Output

{
  "status": "confirmed",
  "tx_hash": "0x123abc...your_tx_hash_here",
  "message": "Transaction successfully processed"
}

Console output:

Transaction Hash: 0x123abc...your_tx_hash_here
Status: confirmed
Message: Transaction successfully processed

4️⃣ How to Run

Save script as check_eth_tx.py
Replace YOUR_RAPIDAPI_KEY with your RapidAPI key
Run:

python check_eth_tx.py

Check console to see the status of your Ethereum transaction

5️⃣ Closing

With this script, you can quickly check Ethereum transaction status without running your own node or relying on multiple providers.

This is perfect for wallets, dApps, or monitoring tools. Explore more endpoints like balance or token transfers using the Crypto API Service on RapidAPI.

Suggested Tags

python, fastapi, crypto, ethereum, api, tutorial

💰 How to Easily Check Multi-Chain Crypto Wallet Balances with Multichain Crypto API

Zaenal Arifin — Mon, 08 Dec 2025 03:48:20 +0000

💰 How to Easily Check Multi-Chain Crypto Wallet Balances with Multichain Crypto API

Crypto developers often face challenges when checking wallet balances or transaction statuses across multiple blockchains. Doing it manually can be tedious, especially if you need to support Solana, Ethereum, BSC, Polygon, TRON, or Base at the same time.

Fortunately, the Multichain Crypto API 🎉 allows developers to directly query blockchain data via ready-to-use API endpoints, without running nodes themselves.

🛠️ Setup

Python 3.11+
Install dependencies:

pip install httpx asyncio

RapidAPI key (sign up and subscribe to Multichain Crypto API)

⚡ Python Async Example

Create a file called check_balance.py:

import asyncio
import httpx
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

API_URL = "https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/balance"
API_KEY = "YOUR_RAPIDAPI_KEY"

async def get_balance(chain: str, wallet: str):
    async with httpx.AsyncClient() as client:
        try:
            resp = await client.get(
                API_URL,
                params={"chain": chain, "wallet": wallet},
                headers={"X-RapidAPI-Key": API_KEY}
            )
            resp.raise_for_status()
            data = resp.json()
            logger.info(f"Balance data: {data}")
            return data
        except httpx.HTTPError as e:
            logger.error(f"Failed to fetch data: {e}")
            return None

async def main():
    chain = "sol"
    wallet = "BnwKsYcEYMCZBTdgTQ8NE3QT79Yj"
    balance_data = await get_balance(chain, wallet)
    if balance_data:
        print(f"Wallet: {balance_data['wallet']}")
        print(f"Chain: {balance_data['chain']}")
        print(f"Balance: {balance_data['balance']}")

if __name__ == "__main__":
    asyncio.run(main())

🖥️ CURL Example

Quick test without Python:

curl "https://multichain-crypto-api4.p.rapidapi.com/api/v1/crypto/balance?rpc_url=https://api.devnet.solana.com&chain=sol&wallet=BnwKsYcEYMCZBTdgTQ8NE3QT79YjzzBdjevPQFKvd4B5" \
  -H "X-RapidAPI-Key: YOUR_RAPIDAPI_KEY" \
  -H "X-RapidAPI-Host: multichain-crypto-api4.p.rapidapi.com"

Notes:

Replace YOUR_RAPIDAPI_KEY with your key
Use testnet wallet for safety

📊 Sample Output

{
  "status": "ok",
  "chain": "sol",
  "wallet": "BnwKsYcEYMCZBTdgTQ8NE3QT79Yj",
  "balance": 12.345
}

Console output:

Wallet: BnwKsYcEYMCZBTdgTQ8NE3QT79Yj
Chain: sol
Balance: 12.345

▶️ How to Run

Save the script as check_balance.py
Replace YOUR_RAPIDAPI_KEY with your RapidAPI key
Run:

python check_balance.py

See the wallet balance printed on the console

🔗 Explore More Endpoints

Check out the Multichain Crypto API on RapidAPI for more endpoints and integrations.

💡 Pro Tip: Combine this API with webhooks or alert systems for real-time balance notifications — perfect for traders or devs needing instant data.

How to Install DVWS (Damn Vulnerable Web Services) on Nginx

Zaenal Arifin — Sat, 01 Nov 2025 05:38:31 +0000

DVWS (Damn Vulnerable Web Services) is a deliberately vulnerable web application for learning web and API penetration testing. Below is a complete, improved step-by-step guide to install DVWS on an Ubuntu + Nginx server plus important production safety notes and alternatives.

Prerequisites
Step 1 — Update & install packages
Step 2 — Install PHP-FPM and required PHP extensions
Step 3 — Create Nginx site configuration for DVWS
Step 4 — Enable site & test configuration
Step 5 — Download DVWS and set permissions
Step 6 — Verify in browser
Extra recommendations & missing pieces added
Quick Docker alternative
Final security & ethical notes

Prerequisites

A server running Ubuntu (the commands below assume Debian/Ubuntu).
sudo privileges.
Nginx not already serving a conflicting site on port 80 (or use alternate port).
Important: DVWS is intentionally insecure — do not expose it to the public Internet without containment (use private network, VPN, or local VM).

Step 1 — Update & install base packages

sudo apt update
sudo apt upgrade -y

# install nginx, git, unzip (if needed)
sudo apt install -y nginx git unzip

Step 2 — Install PHP-FPM and common PHP extensions

DVWS is PHP based. Install PHP-FPM and common extensions that web apps often need. Adjust PHP version (7.4, 8.0, 8.1) to your system.

# contoh: install PHP 8.1 (ubah versi jika perlu)
sudo apt install -y php8.1-fpm php8.1-cli php8.1-mbstring php8.1-xml php8.1-curl php8.1-zip php8.1-mysql

Verify PHP-FPM socket path (you'll need this for Nginx config):

ls /run/php
# contoh output: php8.1-fpm.sock

If you use a different PHP version, update the socket path in Nginx config accordingly (e.g. /run/php/php7.4-fpm.sock or /run/php/php8.1-fpm.sock).

Step 3 — Configure Nginx for DVWS

Create a new site config (use vim if you edit). Example path: /etc/nginx/sites-available/dvws.

sudo vim /etc/nginx/sites-available/dvws

Paste this (adjust server_name and root to match your environment):

server {
    listen 80;
    server_name your_domain_or_ip;   # ganti dengan domain atau IP

    root /var/www/html/DVWS;
    index index.php index.html;

    # Serves static files or falls back to index.php
    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    # PHP processing
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        # pastikan path socket sesuai versi PHP-FPM yang terpasang
        fastcgi_pass unix:/run/php/php8.1-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }

    # Deny access to hidden files (like .env, .git)
    location ~ /\. {
        deny all;
    }

    # Optional: limit large uploads (if needed)
    client_max_body_size 10M;
}

Notes:

Replace your_domain_or_ip with your server IP or domain.
Check the exact php-fpm socket under /run/php and update fastcgi_pass accordingly.

Step 4 — Enable the site and test Nginx

# create symlink
sudo ln -s /etc/nginx/sites-available/dvws /etc/nginx/sites-enabled/

# test nginx config
sudo nginx -t

# restart nginx to apply changes
sudo systemctl restart nginx

If nginx -t reports errors, fix them before restarting.

Step 5 — Download DVWS and set permissions

Clone the DVWS repository into the configured root.

sudo git clone https://github.com/interference-security/DVWS.git /var/www/html/DVWS

# set owner to www-data (nginx default user) and adjust permissions
sudo chown -R www-data:www-data /var/www/html/DVWS
sudo find /var/www/html/DVWS -type d -exec chmod 755 {} \;
sudo find /var/www/html/DVWS -type f -exec chmod 644 {} \;

If DVWS needs writable directories (e.g. uploads), make only those directories writable by the web server:

sudo chown -R www-data:www-data /var/www/html/DVWS/uploads
sudo chmod 770 /var/www/html/DVWS/uploads

Step 6 — Access DVWS via browser

Open in your browser:

http://your_domain_or_ip/

You should see the DVWS interface. If you get a 500 / PHP error, check:

PHP-FPM service: sudo systemctl status php8.1-fpm
Nginx error log: /var/log/nginx/error.log
PHP-FPM log: /var/log/php8.1-fpm.log (path may differ)

7 — Extra recommendations & missing items I added

I added several practical and security-related steps that were missing in the original text:

7.1 PHP extensions

Install common PHP extensions (mbstring, xml, curl, zip, mysql etc.) — many web apps require them.

7.2 Nginx `nginx -t` validation

Always validate Nginx config before restart.

7.3 Correct PHP socket path

Check /run/php for the right socket (or use 127.0.0.1:9000 if using TCP). Many guides forget to adjust this and PHP will fail.

7.4 Minimal permissions principle

Only make truly necessary dirs writable — avoid 777. Set owner to www-data.

7.5 Database / dependencies

If DVWS requires a database (MySQL/MariaDB), install and initialize it:

sudo apt install -y mariadb-server
sudo mysql_secure_installation
# create db/user if DVWS needs one

Read DVWS README to confirm if it requires DB setup.

7.6 Firewall & network isolation

Use ufw to restrict access:

sudo apt install -y ufw
sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'   # 80 and 443 if you enable SSL
sudo ufw enable

Prefer running DVWS in private network or local VM, not exposed publicly.

7.7 HTTPS (optional but recommended for realistic testing)

For real-world simulation and secure access, enable HTTPS with Let's Encrypt (only if you intend to expose it safely):

sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d your_domain

For local/isolated testing, HTTPS is optional.

7.8 SELinux / AppArmor considerations

If using a distro with SELinux (CentOS/RHEL) or AppArmor restrictions, you may need to allow nginx/php-fpm access to the document root. On Ubuntu, AppArmor profiles can block access — check logs if you get permission denied.

7.9 Logging & troubleshooting

Nginx access/error logs: /var/log/nginx/
PHP-FPM logs (path depends on PHP version): check systemd journal or /var/log/.

7.10 Use a VM or container for safety

Because DVWS is intentionally vulnerable, run it inside:

a local VM (VirtualBox, Vagrant), or
an isolated Docker container, or
a private network / VPN.

8 — Quick Docker alternative (safer & easier to tear down)

If you prefer Docker (recommended for isolation), do this:

# Dockerfile example (very simple)
FROM php:8.1-fpm
RUN apt-get update && apt-get install -y nginx git unzip
# install additional PHP extensions as needed
# copy DVWS into /var/www/html and configure nginx inside container or use separate nginx container

Or run a ready Nginx + PHP-FPM container and mount DVWS into /var/www/html. Using Docker Compose with separate nginx and php-fpm services is common.

9 — Final security and ethical notes (important)

DVWS is intentionally vulnerable. Use only on systems you own or have explicit permission to test.
Do not expose DVWS to the public Internet unless you fully isolate it (VPN, firewall, private subnet).
Clean up or destroy the VM/container after testing.
Use best practices when reusing any configuration in production (strict permissions, updated packages, remove sample/test apps).

10 — Troubleshooting quick checklist

sudo nginx -t — config syntax ok?
systemctl status php*-fpm — PHP-FPM running?
Check socket: ls /run/php/ and match fastcgi_pass.
Logs: /var/log/nginx/error.log, /var/log/nginx/access.log, PHP-FPM logs.
Permissions: owner www-data:www-data, no 777.

🧩 How to Structure a FastAPI Project the Right Way

Zaenal Arifin — Sat, 01 Nov 2025 05:32:29 +0000

When you first start with FastAPI, it’s tempting to throw everything into a single file — and it works fine… until your app grows. Then suddenly, your codebase becomes spaghetti.

In this post, we’ll go through how to structure a FastAPI project properly, using clean architecture principles that scale easily.

🚀 Why Project Structure Matters

A good structure makes your project:

Easier to maintain and scale.
Easier for new developers to understand.
Ready for testing, CI/CD, and deployment.

If your FastAPI project looks like this:

main.py
models.py
routes.py
schemas.py
database.py

…it’s time for an upgrade.

🏗️ Recommended Folder Structure

Here’s a clean, production-ready structure I use for real projects:

app/
├── api/
│   ├── routes/
│   │   ├── users.py
│   │   ├── items.py
│   │   └── __init__.py
│   ├── deps.py
│   ├── __init__.py
│   └── api_v1.py
├── core/
│   ├── config.py
│   ├── security.py
│   └── __init__.py
├── db/
│   ├── base.py
│   ├── session.py
│   └── __init__.py
├── models/
│   ├── user.py
│   ├── item.py
│   └── __init__.py
├── schemas/
│   ├── user.py
│   ├── item.py
│   └── __init__.py
├── services/
│   ├── user_service.py
│   └── __init__.py
├── main.py
└── __init__.py

⚙️ Let’s Break It Down

`core/`

Contains global configurations — environment variables, security settings, and constants.

# app/core/config.py
from pydantic import BaseSettings

class Settings(BaseSettings):
    APP_NAME: str = "My FastAPI App"
    DATABASE_URL: str

    class Config:
        env_file = ".env"

settings = Settings()

`db/`

Handles all database setup — connection, session management, and base models.

# app/db/session.py
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from app.core.config import settings

engine = create_engine(settings.DATABASE_URL)
SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)

`api/routes/`

Organize endpoints by domain — one file per feature.

# app/api/routes/users.py
from fastapi import APIRouter, Depends
from app.schemas.user import User
from app.services.user_service import get_all_users

router = APIRouter(prefix="/users", tags=["users"])

@router.get("/", response_model=list[User])
async def list_users():
    return await get_all_users()

`services/`

Business logic lives here — keep it separate from routes.

# app/services/user_service.py
from app.db.session import SessionLocal
from app.models.user import User

async def get_all_users():
    db = SessionLocal()
    return db.query(User).all()

`main.py`

The entry point that ties everything together.

# app/main.py
from fastapi import FastAPI
from app.api.api_v1 import api_router
from app.core.config import settings

app = FastAPI(title=settings.APP_NAME)
app.include_router(api_router)

🧠 Tips for Scalable FastAPI Projects

✅ Use Pydantic models for input/output validation
✅ Split logic into layers — routes, services, models
✅ Use dependency injection for clean imports
✅ Add logging early — don’t debug with print()
✅ Separate environment variables from code

🧰 Example Repository

I’ve uploaded an example of this structure here:
👉 GitHub - fastapi-clean-structure (insert your repo link)

You can clone it, install dependencies, and start your app in seconds:

git clone https://github.com/yourusername/fastapi-clean-structure.git
cd fastapi-clean-structure
poetry install
poetry run uvicorn app.main:app --reload

🔚 Conclusion

Clean project structure isn’t just about being “organized” — it’s about future-proofing your codebase.
FastAPI makes things fast, but structure makes them sustainable.

If you found this useful, drop a ❤️ or follow me — I post about Python, FastAPI, and backend architecture regularly.

🚀 Deploying a FastAPI Project to an Ubuntu VPS — A Complete Guide for Developers

Zaenal Arifin — Sat, 01 Nov 2025 05:24:58 +0000

As an independent developer, I often get asked: how do you deploy a Python project to a VPS so it runs automatically and stays stable?

Well, in this article, I’ll walk you through step-by-step how to host a FastAPI project (or a Python bot) on an Ubuntu VPS — complete with systemd, Nginx, and SSL setup.

1. Why Use a VPS?

If you’ve been coding backend projects for a while, chances are you want your project to be accessible online — whether it’s an API, a bot, or a web dashboard.

A VPS (Virtual Private Server) gives you:

Full freedom (root access)
Ability to install anything (Python, Docker, etc.)
Faster and more stable than shared hosting

Popular providers:

👉 DigitalOcean, Vultr, Linode, Hetzner, or HostHatch.

2. VPS Preparation

ssh root@ip-address-vps

Then update the system and install basic packages:

sudo apt update && sudo apt upgrade -y
sudo apt install python3 python3-venv python3-pip git nginx ufw -y

💡 Security Tips:

Create a non-root user:

adduser ubuntu
usermod -aG sudo ubuntu

Set up the UFW firewall:

ufw allow OpenSSH
ufw allow 'Nginx Full'
ufw enable

3. Clone Project to the Server

Go to a safe directory to store your source code:

cd /opt
sudo git clone https://github.com/username/project.git
sudo chown -R ubuntu:ubuntu project
cd project

If you’re using Poetry, install it first:

curl -sSL https://install.python-poetry.org | python3 -
export PATH="$HOME/.local/bin:$PATH"
poetry install --no-root

Or use the standard venv:

python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

4. Run the Project Manually (Test)

Test your project manually first:

poetry run uvicorn app.main:app --host 0.0.0.0 --port 8000

Or, if using venv:

venv/bin/uvicorn app.main:app --host 0.0.0.0 --port 8000

Then open your browser:
👉 http://<vps-ip>:8000

If you see the FastAPI default page — it’s running fine.

5. Create a Systemd Service

To make the project auto-start on VPS reboot and manageable via systemctl.

Create a new service file:

sudo vim /etc/systemd/system/fastapi.service

Add the following:

[Unit]
Description=FastAPI Application
After=network.target

[Service]
User=ubuntu
WorkingDirectory=/opt/project
ExecStart=/home/ubuntu/.local/bin/poetry run uvicorn app.main:app --host 127.0.0.1 --port 8000
Restart=always
Environment="PATH=/home/ubuntu/.local/bin:/usr/bin"

[Install]
WantedBy=multi-user.target

Activate the service:

sudo systemctl daemon-reload
sudo systemctl enable fastapi
sudo systemctl start fastapi
sudo systemctl status fastapi

If the status shows active (running) — everything’s good.

💡 Use journalctl -u fastapi -f to view real-time logs.

6. Configure Nginx (Reverse Proxy)

This allows your app to be accessed via port 80/443 (HTTP/HTTPS).

Create a new config file:

sudo vim /etc/nginx/sites-available/fastapi

Add the following:

server {
    server_name yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Enable the config:

sudo ln -s /etc/nginx/sites-available/fastapi /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Now open your browser:
👉 http://yourdomain.com

If it loads correctly — your setup is complete.

7. Install Free SSL (Let’s Encrypt)

Use certbot:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d yourdomain.com

SSL will be automatically installed and Nginx updated to HTTPS.

Check status:

sudo systemctl reload nginx

8. Testing & Monitoring

Test your service:

curl -I https://yourdomain.com

View real-time logs:

sudo journalctl -u fastapi -f

Restart service after code updates:

sudo systemctl restart fastapi

9. Extra Tips for Developers

Use tmux to keep manual sessions running.
Add auto-deploy via Git hook:

  git pull && sudo systemctl restart fastapi

Save logs to a custom file in /var/log/fastapi.log.
If you run multiple projects, create separate systemd services for each.
Use fail2ban to secure SSH and Nginx.

10. Conclusion

Now you have a VPS that:

Runs FastAPI 24/7
Is secure, auto-started, and SSL-ready
Can be redeployed easily with git pull + restart

With this setup, you can professionally and efficiently deploy backends, Telegram bots, or internal APIs.

In the next article, I’ll cover auto-deploy CI/CD using GitHub Actions directly to your VPS — stay tuned!

💬 Bonus: Quick Multi-App systemd Template

If you have multiple projects (e.g., a bot and a web app):

sudo vim /etc/systemd/system/telegram-bot.service
sudo vim /etc/systemd/system/fastapi.service

Each can auto-run and be monitored with:

sudo systemctl status telegram-bot
sudo systemctl status fastapi

Building a Bot Platform with Django: Step-by-Step Guide to Creating Bot Platform With Django

Zaenal Arifin — Sun, 06 Oct 2024 02:52:50 +0000

👋 Hey Devs!

I’m excited to share something I’ve been working on for a while — my new ebook titled "Building a Bot Platform with Django." If you’ve ever wanted to create your own bot platform where users can make bots for Telegram and WhatsApp, this book is for you.

What Can You Expect?

In this ebook, I break down how to:

Build a bot creation platform using Django.
Set up Telegram and WhatsApp bots using webhooks.
Add custom commands and responses that make your bots interactive.
Integrate with Twilio to get your WhatsApp bot running.

The best part? This guide takes you through every stage of building the platform, from setting up the initial project to deploying it live. You don’t need to be a Django expert to follow along; the book is designed for developers of all levels!

Why You Should Get It:

Bots are becoming a critical part of business communication, automating everything from customer service to task management. With this ebook, you’ll have the skills to create bots that your users or clients can interact with effortlessly.

Who Is This For?

Django developers looking for a fun new project.
Anyone interested in bot automation using messaging platforms.
Developers who want to integrate real-time interaction into their apps.

Ready to start building?

Grab your copy of "Building a Bot Platform with Django" now at aigoretech/ebook.

Want to Get Promo & Discounts?

Join my Discord community to stay updated on exclusive promotions and discounts. Connect with me and other developers by joining here: discord.gg/GNhjPqeX4g.

If you have any questions about the book, feel free to drop a comment or reach out! I’m happy to chat about all things Django and bots. 🚀

Belajar Machine Learning dengan Python dan Library Scikit-Learn

Zaenal Arifin — Sun, 29 Sep 2024 10:03:14 +0000

📚 Belajar Machine Learning dengan Python dan Library Scikit-Learn 🤖📊

Apakah Anda ingin memulai perjalanan di dunia machine learning? Buku ini adalah panduan lengkap yang dirancang untuk membantu pembaca memahami konsep dasar dan aplikasi praktis machine learning menggunakan Python dan library Scikit-Learn yang populer. Cocok untuk pemula maupun praktisi yang ingin memperdalam pengetahuan mereka tentang teknik-teknik terbaru dalam bidang ini.

📖 Apa yang akan Anda pelajari:

✅ Dasar-dasar machine learning
✅ Teknik preprocessing data
✅ Membangun model machine learning
✅ Evaluasi model dan optimasi kinerja
✅ Penerapan algoritma populer seperti regresi, klasifikasi, dan clustering

Dengan buku ini, Anda akan dibimbing secara langkah demi langkah melalui konsep yang kompleks menjadi sederhana, didukung dengan contoh kode Python yang jelas dan penjelasan yang mendetail. Tak hanya itu, Anda juga mendapatkan akses ke repositori GitHub untuk melihat dan mencoba sendiri kode yang digunakan.

🔗 Dapatkan di:
https://clicky.id/aigoretech/download-ebook
Atau kunjungi:
https://aigoretech.my.id/ebook

Fundamental Machine Learning: Panduan Lengkap untuk Pemula

Zaenal Arifin — Sun, 29 Sep 2024 09:55:24 +0000

📚Fundamental Machine Learning: Panduan Lengkap untuk Pemula🤖📈

Apakah Anda baru memulai perjalanan di dunia machine learning? Ebook ini adalah panduan sempurna bagi pemula untuk memahami konsep-konsep dasar serta aplikasi machine learning di berbagai industri. Dari kesehatan hingga keuangan, e-commerce hingga teknologi, Anda akan mempelajari cara memilih model yang tepat, mengevaluasi performa, dan menerapkan solusi machine learning secara praktis — tanpa harus mendalami kode.

📖Apa yang akan Anda pelajari:

✅ Pengenalan berbagai algoritma machine learning
✅ Aplikasi machine learning dalam industri nyata
✅ Pemilihan model yang tepat untuk berbagai kasus
✅ Teknik evaluasi performa model
✅ Penerapan machine learning tanpa fokus pada kode

Buku ini memberikan pengantar yang mudah dipahami dan disusun dengan contoh-contoh praktis, menjadikannya panduan yang ideal untuk siapa saja yang ingin memahami machine learning dari perspektif konsep dan aplikasi industri.

🔗 Dapatkan di:
https://clicky.id/aigoretech/download-fundamental-machine-learning
Atau kunjungi:
https://aigoretech.my.id/ebook

Membangun Platform Bot dengan Django

Zaenal Arifin — Sun, 29 Sep 2024 09:54:25 +0000

📚 Buku Panduan Lengkap: Membangun Platform Bot dengan Django 🖥️🤖

Apakah Anda ingin membangun platform bot menggunakan Django? Buku ini adalah solusi lengkap untuk Anda! Cocok untuk pemula maupun pengembang berpengalaman, buku ini menyajikan langkah-langkah yang jelas dan praktis untuk menciptakan proyek bot yang siap di-deploy, dengan integrasi sempurna ke Telegram dan WhatsApp.

📲Apa yang akan Anda pelajari:

✅ Cara membuat bot interaktif
✅ Integrasi webhook untuk menghubungkan bot ke layanan eksternal
✅ Manajemen perintah (commands) yang efisien
✅ Implementasi log aktivitas untuk pelacakan performa

📖Buku ini dilengkapi dengan:

Contoh kode yang mudah dipahami
Penjelasan mendetail di setiap langkah
Akses ke repositori GitHub dengan kode lengkap
✨ Diskon Spesial 15% untuk ebook "Membangun Platform Bot dengan Django"! 🎉
Gunakan kode DISKON15 saat checkout. Penawaran ini hanya berlaku hingga 25 Oktober 2024. Segera dapatkan panduan ini dan mulai bangun bot Anda dengan hemat! 💻🚀

🔗Dapatkan di:
https://clicky.id/aigoretech/promo-page
Atau kunjungi:
https://aigoretech.my.id/ebook

DEV Community: Zaenal Arifin

🚀 Panduan Hosting Website di Raspberry Pi + Subdomain

1️⃣ Update & Install Dependency

2️⃣ Clone Project

3️⃣ Test FastAPI Lokal

4️⃣ Setup systemd Service

5️⃣ Setup Nginx sebagai Reverse Proxy

6️⃣ Pasang SSL Gratis dengan Let’s Encrypt

7️⃣ Opsi Subdomain

Opsi 1 – Arahkan langsung ke IP publik

Opsi 2 – Pakai Cloudflare Tunnel (Argo Tunnel)

✅ 1. Buat file service systemd

✅ 2. Reload systemd dan aktifkan service

📌 3. Cek apakah tunnel sudah jalan

🎉 Setelah ini:

🚀 Multichain Crypto API — Full Endpoint Overview

🔧 API Setup

📚 Endpoints Overview

📚 Available Endpoints with CURL Examples & Quick Tutorials

1️⃣ Ping API

2️⃣ Send Native Token (SOL, ETH, BNB, TRON, MATIC, BASE)

3️⃣ Send USDC or USDT

4️⃣ Get Wallet Balance

5️⃣ Get Token Price

6️⃣ Estimate Gas Fee

7️⃣ Get Supported Tokens

8️⃣ Simulate Token Swap

9️⃣ Get Token Metadata

🔟 Get Transaction Status

🔗 Why Use Multichain Crypto API?

How to Send Native Crypto Tokens Across Multiple Blockchains Using FastAPI API

1️⃣ Prerequisites

2️⃣ Understanding the /send/native Endpoint

3️⃣ Example Python Script

4️⃣ Example Output

5️⃣ How to Run

6️⃣ Tips for Safe Token Transfers

7️⃣ Closing

How to Track Ethereum Transaction Status with FastAPI API

1️⃣ Setup

2️⃣ Example Python Script

3️⃣ Example Output

4️⃣ How to Run

5️⃣ Closing

Suggested Tags

💰 How to Easily Check Multi-Chain Crypto Wallet Balances with Multichain Crypto API

🛠️ Setup

⚡ Python Async Example

🖥️ CURL Example

📊 Sample Output

▶️ How to Run

🔗 Explore More Endpoints

How to Install DVWS (Damn Vulnerable Web Services) on Nginx

Table of contents

Prerequisites

Step 1 — Update & install base packages

Step 2 — Install PHP-FPM and common PHP extensions

Step 3 — Configure Nginx for DVWS

Step 4 — Enable the site and test Nginx

Step 5 — Download DVWS and set permissions

Step 6 — Access DVWS via browser

7 — Extra recommendations & missing items I added

7.1 PHP extensions

7.2 Nginx nginx -t validation

7.3 Correct PHP socket path

7.4 Minimal permissions principle

7.5 Database / dependencies

7.6 Firewall & network isolation

7.7 HTTPS (optional but recommended for realistic testing)

7.8 SELinux / AppArmor considerations

7.9 Logging & troubleshooting

7.10 Use a VM or container for safety

8 — Quick Docker alternative (safer & easier to tear down)

9 — Final security and ethical notes (important)

10 — Troubleshooting quick checklist

🧩 How to Structure a FastAPI Project the Right Way

🚀 Why Project Structure Matters

🏗️ Recommended Folder Structure

⚙️ Let’s Break It Down

core/

2️⃣ Understanding the `/send/native` Endpoint

7.2 Nginx `nginx -t` validation

`core/`

`db/`

`api/routes/`

`services/`

`main.py`