API

Overview

One endpoint for orders, status and balance

The LikesFactory API lets you automate everything a reseller needs: sync the live catalogue, place orders including drip-feed, poll status, request refills and cancellations, and read your balance. It follows the industry-standard SMM panel v2 pattern, so it works with standalone websites, custom apps, bots and most reseller tools.

Who it is forAgencies, child-panel owners, bots and custom storefronts that need wholesale automation.

What regular users needNothing — the website dashboard is enough. This page is for integrations only.

Base styleSingle URL, form-encoded body, JSON response, one API key per account.

POST https://likesfactory.com/api/v2

Quick start

From signup to your first API request in minutes

01

Create account

Register and confirm your email.

02

Add funds

Top up balance before placing live orders.

03

Copy API key

Open Account, generate a key and copy it — it is shown once.

04

Send a test request

Start with action=balance or services.

Authentication

One private key secures every request

Every request must include your private API key as key. Treat it like a password: do not publish it in client-side JavaScript, screenshots, tickets or public repositories.

Parameter	Required	Description
`key`	Yes	Your account API key
`action`	Yes	API action name (`add`, `status`, `services`, …)

Your account holds one key at a time. It is shown once, at the moment you generate it on the Account page — copy it then. Generating a new key replaces the previous one immediately, so update your integrations before you rotate.

Send the key in the request body. The endpoint also answers to GET, but a key placed in a query string is recorded in browser history, proxy and server logs, and in the Referer header of every page it reaches. Always use POST.

Actions

Everything you can do with the API

1) Get balance

Check available funds before sending large jobs.

# Request curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=balance" # Response — 100.00 topped up, one 10.00 order placed { "balance": "90.0000000", "currency": "USD" }

Amounts are returned as strings and the number of decimal places varies by field: the balance carries seven, an order charge two or four. Parse the string as a decimal and apply your own formatting rather than relying on a fixed shape.

2) List services

Sync the full catalogue with live rates, limits and refill flags.

# Request curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=services" # Response (excerpt) [ { "service": 18071, "name": "Instagram Followers — Real, No Drop", "type": "Default", "rate": "1.00", "min": 100, "max": 100000, "dripfeed": false, "refill": true, "cancel": true, "category": "Instagram" } ]

Field	Type	Meaning
`service`	Number	Service ID — the value you send as `service` when ordering
`name`	String	Public service name
`type`	String	Order form the service expects, for example `Default` or `Custom Comments`
`rate`	String	Price per 1000 units
`min` / `max`	Number	Allowed quantity range
`dripfeed`	Boolean	Whether `runs` and `interval` are honoured for this service
`refill`	Boolean	Whether a refill can be requested after completion
`cancel`	Boolean	Whether a cancellation can be requested
`category`	String	Catalogue group the service belongs to

Cache this response and read the flags from it. dripfeed, refill and cancel decide which of the calls below will work for a given service, and the catalogue is the only place they are published.

3) Place an order

Create a single order. Always validate the public link and quantity against the service min/max.

Parameter	Required	Description
`action`	Yes	`add`
`service`	Yes	Service ID from the catalogue
`link`	Yes	Public profile/post/video URL
`quantity`	Yes*	Units to deliver (*depends on service type)
`runs` / `interval`	No	Drip-feed: number of runs and the gap between them, in minutes. Send both or neither, and only for services with `dripfeed: true` — see below

# Request curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=add" \ -d "service=18071" \ -d "link=https://instagram.com/example" \ -d "quantity=10000" # Response { "order": 383742 }

<?php $client = curl_init('https://likesfactory.com/api/v2'); curl_setopt_array($client, [ CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_POSTFIELDS => http_build_query([ 'key' => 'YOUR_API_KEY', 'action' => 'add', 'service' => 18071, 'link' => 'https://instagram.com/example', 'quantity' => 10000 ]) ]); $response = curl_exec($client); curl_close($client); echo $response;

import requests response = requests.post( "https://likesfactory.com/api/v2", data={ "key": "YOUR_API_KEY", "action": "add", "service": 18071, "link": "https://instagram.com/example", "quantity": 10000, }, timeout=30, ) print(response.json())

const body = new URLSearchParams({ key: 'YOUR_API_KEY', action: 'add', service: '18071', link: 'https://instagram.com/example', quantity: '10000' }); const response = await fetch( 'https://likesfactory.com/api/v2', { method: 'POST', body } ); console.log(await response.json());

4) Drip-feed orders

Drip-feed splits one order into equal runs delivered on a fixed interval. Add runs and interval to the same add call — there is no separate action.

# Request — 2 runs of 1000, one hour apart curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=add" \ -d "service=18094" \ -d "link=https://www.tiktok.com/@example/video/123" \ -d "quantity=1000" \ -d "runs=2" \ -d "interval=60" # Response { "order": 383744 }

What to expect	Detail
Total delivered	`quantity × runs` — here 2000 units
Total charged	`quantity × runs × rate ÷ 1000`, taken in full when the order is created
Order IDs	The ID returned is a parent. Each run is created as its own order with its own ID
Status shape	The parent returns a different object from a normal order — see the next section

Check dripfeed in the service list before sending these parameters. On a service without drip-feed the order is still accepted, but runs and interval are ignored and a single run is delivered and charged.

5) Order status

Poll one order or several IDs in a single call for dashboards and automations.

Parameter	Required	Description
`action`	Yes	`status`
`order`	Yes*	Single order ID
`orders`	Yes*	Comma-separated order IDs, up to 100 per call (*send `order` or `orders`; if both are present, `order` is used and the answer arrives in the multi-order shape)

# Single order curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=status" \ -d "order=383742" # Response { "charge": "10.00", "start_count": "", "status": "Pending", "remains": "10000", "currency": "USD" } # Multiple orders — keyed by ID, unknown IDs answer individually curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=status" \ -d "orders=383742,383744,900000" # Response { "383742": { "charge": "10.00", "start_count": "", "status": "Pending", "remains": "10000", "currency": "USD" }, "383744": { "status": "Active", "runs": "2", "orders": ["383745", "383746"] }, "900000": { "error": "Incorrect order ID" } }

Field	What it tells you
`charge`	Amount taken for the order, exact and unrounded — a small order can come back as `"0.0225"`. Becomes `"0.00"` once an order has been cancelled and refunded
`start_count`	Counter read before delivery began. An empty string until it has been read — treat it as "not available yet", not as zero
`remains`	Units still to deliver. On a cancelled order it keeps the original quantity, so read `status` first
`status`	See the status table below

A drip-feed parent answers with status, runs and an orders array instead of the usual fields — no charge, remains or currency. Read the child IDs from orders and poll those for delivery progress.

6) Request refill

Available for services with refill: true, once the order is Completed and while it is still inside the refill window.

# Single order curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=refill" \ -d "order=383742" # Response — the number is a refill ID, not an order ID { "refill": "4821" } # Multiple orders, up to 100 per call curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=refill" \ -d "orders=383742,383743" # Response — one entry per order [ { "order": 383742, "refill": 4821 }, { "order": 383743, "refill": { "error": "The order is not completed" } } ]

Keep the refill ID — it is the only way to follow the request. The order is not completed is also the answer when the service has no refill at all, so read the refill flag from the service list rather than inferring it from this message.

7) Refill status

Follow a refill request through to its result.

# Single refill curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=refill_status" \ -d "refill=4821" # Response { "status": "Completed" } # Multiple refills, up to 100 per call curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=refill_status" \ -d "refills=4821,4822" # Response [ { "refill": 4821, "status": "Completed" }, { "refill": 4822, "status": { "error": "Refill not found" } } ]

8) Request cancellation

Available for services with cancel: true, while the order has not been delivered.

# Single order — the number is a cancellation ID curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=cancel" \ -d "order=383742" # Response { "cancel": 317 } # Multiple orders, up to 100 per call curl -X POST https://likesfactory.com/api/v2 \ -d "key=YOUR_API_KEY" \ -d "action=cancel" \ -d "orders=383742,383743" # Response — one entry per order [ { "order": 383742, "cancel": 317 }, { "order": 383743, "cancel": { "error": "Cancel unavailable. Try again later." } } ]

This call registers a cancellation request and returns its ID. The order keeps its current status and the balance does not change until the request has been processed, so poll status rather than assuming the order has stopped. Cancel unavailable means either that the service does not allow cancellation or that a request already exists for that order.

Order statuses

Status	Meaning
`Awaiting`	Accepted and waiting to be picked up
`Pending`	Queued, not started yet
`Processing`	Being sent for delivery
`In progress`	Delivery has started
`Completed`	Delivery finished
`Partial`	Part delivered; the undelivered remainder is settled on the balance
`Canceled`	Stopped and refunded — `charge` becomes `"0.00"`
`Fail`	Could not be delivered
`Error`	Stopped by a problem with the request or the delivery
`Active`	Only on a drip-feed parent: runs are still being created

Errors & good practices

One check for every response

A response is an error when the JSON contains an error key. That single check covers every request on this page. HTTP status codes are not a reliable signal here — an invalid key answers 401 and an unknown action 404, but validation errors arrive with 200 OK and the reason in the body. Test the body, not the code.

# Python data = response.json() if isinstance(data, dict) and "error" in data: raise RuntimeError(data["error"]) # PHP $data = json_decode($response, true); if (isset($data['error'])) { throw new RuntimeException($data['error']); }

In multi-ID calls the error sits inside the entry it belongs to, so a single bad ID never spoils the rest of the batch. Check each entry.

Messages you can expect

Message	HTTP	What it means
`Invalid API key`	401	The key is wrong or has been replaced by a newer one
`Incorrect request`	404	`action` is missing or is not one of the actions on this page
`Incorrect service ID`	200	No service with that ID — resync the catalogue
`Bad link`	200	`link` is missing or is not a usable URL
`Quantity less than minimal 100`	200	Below the service minimum; the number in the message is that minimum
`You have active order with this link. Please wait until order being completed.`	200	An order for the same service and link is still running
`Incorrect order ID`	200	No order with that ID on your account
`The order is not completed`	200	Refill was requested before the order finished, or the service has no refill
`Refill not found`	200	No refill request with that ID
`Cancel unavailable. Try again later.`	200	The service does not allow cancellation, or a request already exists for that order

Nothing is charged when a request fails validation — the balance is untouched, and no order is created.

How often you can send requests

There is no published per-key limit. Requests are answered in turn: thirty sent at once were all answered, at roughly ten a second in total. Treat that as the ceiling of the road rather than the speed to drive at — if a limit is ever applied it will arrive the way every other failure on this page does, a JSON body carrying an error key rather than an HTTP 429, so the check you already have catches it. A child panel has its own key, counted separately from yours.

Two habits keep an integration comfortable. Ask for many orders in one status request with the multi-ID form instead of one request per order, and leave a short pause between requests in a loop rather than sending them as fast as the code can produce them.

Good practice

Resync the catalogue regularly and validate service, link and quantity against it before ordering.
Store the order ID returned by add, and the refill and cancellation IDs — they are the only handles you get.
Poll status on a steady schedule rather than continuously; once a minute is ample for most integrations, and it keeps you well inside the rate limit above.
Log the order ID and the error message when something goes wrong, and quote them in a ticket. Never include your key.

Security checklist

Keep your key and your customers safe

Call the API only from your server or trusted backend — never from public browser code.
Send the key in the request body. Never place it in a URL, where it would be kept in logs and browser history.
An account has one key. If it leaks, generate a new one on the Account page — the old key stops working at once, so update your integrations first.
Never send passwords of social accounts — only public links.
Log order IDs and error messages for support tickets, not the full API key.

Child panels

A ready-made storefront without writing code

Prefer your own storefront without building one? Use a child panel — a fully white-label panel on your domain, with your logo and retail prices; fulfilment runs through your LikesFactory balance. Full product details live on the child panels page.

API provider modeBest if you already run your own website, panel script or custom store — use this documentation.

Child panel modeBest if you want your own storefront quickly without building a full product.

Your marginBuy wholesale from LikesFactory and sell at your own retail rates.

Explore child panels →

API FAQ

Quick answers for integrators

No. The website dashboard is enough for most users. The API is optional and aimed at resellers, agencies and automations.

Yes. The API is plain HTTPS with JSON responses, so any backend — a custom site, mobile app, bot or CRM — can integrate it. It also stays compatible with standard SMM reseller software and child-panel scripts.

Sign in, open the Account page and press Generate a new key in the API key block. The key is displayed once, so copy it there and then, and store it securely on your server. Generating another key replaces the current one immediately.

Yes, on services with dripfeed: true in the catalogue. Add runs and interval to the same add call. On a service without drip-feed those parameters are ignored and a single run is delivered, so read the flag from action=services before you send them.

Read the status response first — it carries the current state and how much is still outstanding. On a Partial order the undelivered remainder is settled on your balance, and a cancelled order is refunded in full, with charge becoming "0.00". For anything unresolved, open a ticket with the order ID — never with your API key.

Production-ready SMM panel API for resellers and agencies