How do I get an SMM panel API key?

After creating an account and funding your balance, go to your profile or settings page in the SMM panel. There will be an 'API' or 'Developer' section with your personal API key and the base API URL.

What actions can I perform via SMM panel API?

Standard SMM panel APIs support: listing all available services (with IDs and prices), placing new orders, checking order status, getting your account balance, and creating refill requests.

Can I build my own SMM panel using the API?

Yes. Most resellers build a custom front-end website, take orders from their own customers at marked-up prices, then use the wholesale panel API to fulfill those orders automatically. This is the standard reseller business model.

SMM Panel API Guide 2026: How to Automate Social Media Orders at Scale

Q: What is an SMM panel API?

An SMM panel API is an HTTP interface that lets you place, track, and manage social media service orders programmatically — without logging into the panel dashboard. You send requests with your API key and get JSON responses back.

The SMM panel API is what separates someone who logs in and clicks buttons from someone running a business. Once you understand how it works, you can automate order placement, build your own reseller storefront, integrate social media fulfillment into any web app, and manage hundreds of orders without touching a dashboard.

This guide covers everything from authentication to error handling to production code you can actually run.

What the SMM Panel API Does

Every modern SMM panel exposes an HTTP API — typically REST-style, with POST requests and JSON responses. You authenticate with an API key (no OAuth, no rotating tokens), and the available actions are standardized across most panels:

Action	What It Does	Returns
services	List all available services with IDs and prices	Array of service objects
add	Place a new order	Order ID
status	Get status of a single order	Status, start count, remains
status (multiple)	Status of multiple orders in one call	Array of order statuses
balance	Check your account balance	Balance amount and currency
refill	Request a refill on an eligible order	Refill ID
refill (status)	Check status of a refill request	Status string
cancel	Cancel one or more pending orders	Cancelled/error status

Authentication: API Keys

There's no OAuth dance. Every request includes your API key as a POST parameter. Get it from your account's API or Settings page.

Your API key is like a password — it directly authorizes spending from your balance. Never expose it in frontend JavaScript, never commit it to a public repo, always load it from an environment variable.

Every request to LikePro's API uses this base URL:

https://likepropanel.com/api/v2

Every call is a POST request with Content-Type: application/x-www-form-urlencoded. The key parameter is always required. The action parameter defines what you're doing.

Getting Your Service List

Before you can order anything, you need the service ID. The services endpoint returns every available service with its ID, name, rate (per 1,000), minimum, maximum, and category.

# Python — fetch all services
import requests, os

API_KEY = os.environ["SMM_API_KEY"]
BASE_URL = "https://likepropanel.com/api/v2"

response = requests.post(BASE_URL, data={
    "key": API_KEY,
    "action": "services"
})

services = response.json()

# Find Instagram follower services
for s in services:
    if "instagram" in s["name"].lower() and "follower" in s["name"].lower():
        print(f"{s['service_id']} | {s['name']} | ${s['rate']}/1K")

// PHP — fetch all services

$api_key = getenv('SMM_API_KEY');
$base_url = 'https://likepropanel.com/api/v2';

$response = file_get_contents($base_url, false, stream_context_create([
    'http' => [
        'method'  => 'POST',
        'header'  => 'Content-Type: application/x-www-form-urlencoded',
        'content' => http_build_query([
            'key'    => $api_key,
            'action' => 'services'
        ])
    ]
]));

$services = json_decode($response, true);
var_dump($services[0]); // first service object

Service Object Fields

Field	Type	Description
`service_id`	int	Use this in your order calls
`name`	string	Human-readable service name
`category`	string	Service category (e.g., "Instagram Followers")
`rate`	string	Price per 1,000 in USD
`min`	int	Minimum order quantity
`max`	int	Maximum order quantity
`type`	string	"Default", "Custom Comments", "Mentions", "Subscriptions"
`refill`	bool	Whether the service supports refills
`cancel`	bool	Whether the service supports cancellation
`dripfeed`	bool	Whether drip-feed delivery is available

Placing an Order

The add action places an order. Required parameters: service (the service ID), link (the target URL), and quantity.

# Python — place an order
import requests, os

def place_order(service_id, link, quantity):
    response = requests.post("https://likepropanel.com/api/v2", data={
        "key": os.environ["SMM_API_KEY"],
        "action": "add",
        "service": service_id,
        "link": link,
        "quantity": quantity
    })
    result = response.json()

    if "error" in result:
        raise Exception(f"Order failed: {result['error']}")

    return result["order"]  # returns order ID as integer

# Example
order_id = place_order(123, "https://instagram.com/yourprofile", 1000)
print(f"Order placed: {order_id}")

// PHP — place an order
function placeOrder($service_id, $link, $quantity) {
    $response = file_get_contents('https://likepropanel.com/api/v2', false,
        stream_context_create(['http' => [
            'method'  => 'POST',
            'header'  => 'Content-Type: application/x-www-form-urlencoded',
            'content' => http_build_query([
                'key'      => getenv('SMM_API_KEY'),
                'action'   => 'add',
                'service'  => $service_id,
                'link'     => $link,
                'quantity' => $quantity
            ])
        ]])
    );

    $result = json_decode($response, true);

    if (isset($result['error'])) {
        throw new Exception("Order failed: " . $result['error']);
    }

    return $result['order']; // order ID
}

Optional Order Parameters

Parameter	When to Use	Example
`runs` + `interval`	Drip-feed: spread delivery over time	runs=10, interval=60 (every 60 min)
`comments`	Custom Comments service type	Newline-separated comment list
`username`	Some Mentions services	The target @handle

Checking Order Status

Once you have an order ID, poll its status. Don't hammer the API — polling every 60 seconds is plenty for most services. Most panels enforce rate limits.

# Python — check single order status
def get_order_status(order_id):
    response = requests.post("https://likepropanel.com/api/v2", data={
        "key": os.environ["SMM_API_KEY"],
        "action": "status",
        "order": order_id
    })
    return response.json()

# Response structure:
# {
#   "charge": "0.27",
#   "start_count": "1247",
#   "status": "Partial",
#   "remains": "500",
#   "currency": "USD"
# }

Order Status Values

Status	Meaning	Action
Pending	In queue, not started	Wait
In progress	Actively being fulfilled	Wait
Completed	Done — all quantity delivered	Done
Partial	Delivered what it could, stopped	Note remaining for possible refund
Cancelled	Cancelled by system or request	Check for credit
Processing	Being reviewed/prepared	Wait

Bulk Status Check

To avoid hammering the API with individual status calls, you can check multiple orders at once:

# Python — check multiple orders
def get_bulk_status(order_ids):
    # order_ids = [1001, 1002, 1003]
    response = requests.post("https://likepropanel.com/api/v2", data={
        "key": os.environ["SMM_API_KEY"],
        "action": "status",
        "orders": ",".join(str(i) for i in order_ids)
    })
    return response.json()  # dict keyed by order ID

Checking Your Balance

# Python
def get_balance():
    response = requests.post("https://likepropanel.com/api/v2", data={
        "key": os.environ["SMM_API_KEY"],
        "action": "balance"
    })
    data = response.json()
    return float(data["balance"])  # e.g., 42.50

Run a balance check before placing bulk orders. If you're building an automated system, implement a low-balance alert so orders don't fail silently.

Error Handling

When something goes wrong, the API returns an error key in the JSON response. Common errors:

Error Message	Cause	Fix
Invalid API key	Wrong key or account suspended	Verify key from account settings
Not enough funds	Balance below order cost	Top up balance before ordering
Minimum quantity required: X	Order below service minimum	Use the min value from services list
Maximum quantity allowed: X	Order above service maximum	Split into multiple orders
Invalid link	URL format not recognized	Ensure full URL with https://
Service not found	Service ID doesn't exist or disabled	Refresh your services list
Incorrect order ID	Order ID doesn't belong to your account	Check the ID returned on creation

# Robust error handler — Python
class SMMAapieError(Exception):
    pass

def api_call(data):
    try:
        resp = requests.post(
            "https://likepropanel.com/api/v2",
            data={"key": os.environ["SMM_API_KEY"], **data},
            timeout=30
        )
        resp.raise_for_status()
        result = resp.json()

        if "error" in result:
            raise SMMAapieError(result["error"])

        return result

    except requests.Timeout:
        raise SMMAapieError("API timeout — retry in 30s")
    except requests.ConnectionError:
        raise SMMAapieError("Network error — check connectivity")
    except ValueError:
        raise SMMAapieError("Invalid JSON response")

Building a Reseller Front-End

The most common use case: you build a website where customers order social media services at marked-up prices, and your backend automatically fulfills via the wholesale panel API. Here's the architecture:

System Architecture

Layer	Your Responsibility	Handled By API
Customer UI	HTML/CSS storefront, service selection, order form	—
Payment	Stripe/PayPal integration, balance system	—
Order DB	Store customer orders, map to panel order IDs	—
Fulfillment	API call with service ID, link, quantity	Panel delivers the service
Status sync	Cron job polling order status, updating your DB	Panel tracks progress
Refills	Expose refill button if service supports it	Panel handles the refill

Pricing Model

You buy at wholesale. You sell at retail. The margin is your profit.

Service	Wholesale (LikePro)	Resell Price	Margin
Instagram Followers / 1K	$1.20	$4.00–8.00	233–567%
TikTok Views / 1K	$0.18	$0.80–1.50	344–733%
YouTube Subscribers / 1K	$2.50	$8.00–15.00	220–500%
Spotify Plays / 1K	$0.90	$3.00–5.00	233–456%

Syncing Services from the Panel

# Cron: run daily to refresh service catalog from panel
import sqlite3, requests, os, json

def sync_services():
    services = api_call({"action": "services"})

    conn = sqlite3.connect("reseller.db")
    conn.execute("DELETE FROM services")

    for s in services:
        wholesale_rate = float(s["rate"])
        markup = 3.5  # 250% markup
        retail_rate = round(wholesale_rate * markup, 2)

        conn.execute("""
            INSERT INTO services (panel_service_id, name, category,
              wholesale_rate, retail_rate, min_qty, max_qty, refill, cancel)
            VALUES (?,?,?,?,?,?,?,?,?)
        """, (
            s["service_id"], s["name"], s["category"],
            wholesale_rate, retail_rate, s["min"], s["max"],
            s["refill"], s["cancel"]
        ))

    conn.commit()
    conn.close()
    print(f"Synced {len(services)} services")

Order Fulfillment Flow

# When a customer places an order on your site:
def fulfill_customer_order(customer_order_id, service_id, link, quantity):
    # 1. Get the panel service ID from your DB mapping
    panel_service_id = get_panel_service_id(service_id)

    # 2. Deduct from customer's balance in your system
    deduct_customer_balance(customer_order_id)

    # 3. Place order on the panel
    panel_order_id = api_call({
        "action": "add",
        "service": panel_service_id,
        "link": link,
        "quantity": quantity
    })["order"]

    # 4. Store the mapping in your DB
    store_order_mapping(customer_order_id, panel_order_id)

    return panel_order_id

Status Sync Cron

# Cron: run every 5 minutes
def sync_order_statuses():
    # Get all pending panel order IDs from your DB
    pending_orders = get_pending_panel_order_ids()

    if not pending_orders:
        return

    # Bulk status check (up to 100 at once)
    for chunk in chunks(pending_orders, 100):
        statuses = api_call({
            "action": "status",
            "orders": ",".join(str(i) for i in chunk)
        })

        for panel_order_id, status_data in statuses.items():
            update_order_status(panel_order_id, status_data["status"])

Rate Limits and Best Practices

Pattern	Recommended Approach
Status polling frequency	Every 5–10 minutes for active orders; hourly for near-complete
Bulk status calls	Max 100 order IDs per call
Retry on failure	Exponential backoff: 30s → 2min → 10min
API key storage	Environment variable, never in code or frontend
Service list refresh	Once daily — services change infrequently
Balance monitoring	Alert at $20 remaining — don't let orders fail silently
Link validation	Validate URL format before sending — catches most invalid link errors
Quantity validation	Enforce min/max on your front-end before calling the API

Watch for drip-feed abuse: Some resellers drip-feed every order by default. Only use drip-feed when the customer specifically requests gradual delivery — it slows fulfillment and can frustrate customers expecting fast delivery.

Frequently Asked Questions

What is an SMM panel API?

An HTTP interface that lets you place, track, and manage social media orders programmatically. Send a POST request with your API key and get a JSON response back — no browser, no dashboard needed.

Is the API free to use?

API access is free — you pay only for the orders you place, at the same rates as the dashboard. No additional API fee.

Can I use the API from any programming language?

Any language that can make HTTP POST requests works: Python, PHP, Node.js, Ruby, Go, Java, C#. The examples here are Python and PHP, but the logic is identical across languages.

How do I handle a "Partial" order status?

Partial means the service delivered some but not all of the quantity and stopped. The panel typically issues a partial refund for the undelivered portion automatically. Check your balance after a partial — the credit is usually added within 24 hours.

What's the difference between "status" with "order" vs "orders" parameter?

Using order (singular) returns status for one order. Using orders (plural, comma-separated) returns a dict of statuses for multiple orders in one API call — much more efficient when monitoring a queue.

Get API Access — Start at $1.20/1K

LikePro's API supports all the endpoints documented here. Create a free account, fund your balance, grab your API key from Settings, and start automating within minutes.

Get Your API Key →

SMM Panel API Guide 2026: How to Automate Orders at Scale