Documentation API

KuroNeko API is a fast and free Golang-powered REST API, designed for WhatsApp, Telegram, Discord, and web application bot developers. Check out the complete guide below before starting to call the endpoint

Base Endpoint
https://sylvatica.my.id/api
01/Introduction
INTRO

Introduction

KuroNeko API is a free, high performance REST API built with Golang, giving developers a fast and reliable set of JSON endpoints. It's designed for bot developers building on WhatsApp, Telegram, and Discord, as well as anyone integrating quick JSON utilities into a web app.

Every response follows a predictable JSON structure, and every endpoint below is documented individually, where you can browse, inspect, and test each one directly.

02/Getting Started
START

Getting Started

  1. Create an account via /login using Google or GitHub.
  2. Your API key is generated automatically and can be viewed anytime on your /profile page.
  3. New accounts start on the free Common tier. Visit /shop if you need a higher daily limit.
  4. Browse available endpoints from the sidebar and copy the prepared request example for the one you need.
  5. Make your first request using your API key, as shown below.
03/Authentication
AUTH

Authentication

KuroNeko API uses simple API key authentication. Every request must include a valid key, either as a query parameter or as a header.

API Key Usage

Pass your key using one of these methods:

MethodExample
Query parameter apikey?apikey=YOUR_API_KEY
Query parameter key?key=YOUR_API_KEY
Header X-API-KeyX-API-Key: YOUR_API_KEY

Your key's tier determines your daily request limit. See Rate Limits below for the full breakdown.

04/Making Requests
REQUESTS

Making Requests

HTTP Methods

All KuroNeko API endpoints are called using GET, with parameters passed through the URL query string. No request body is required.

Parameters

ParameterTypeRequiredDescription
apikeystringYes*Your KuroNeko API key.
keystringYes*Alias for apikey.
(varies)variesDependsAdditional parameters are specific to each endpoint. Check the endpoint card for the exact list.

*Either apikey or key is required, unless you're authenticating via the X-API-Key header.

Query Parameters

Combine your key with additional parameters using &, and make sure values are URL encoded:

Example
GET /api/example?apikey=YOUR_API_KEY&text=Hello%20World

Headers

HeaderRequiredDescription
X-API-KeyOptionalAlternative to the apikey query parameter.
AcceptOptionalResponses are always returned as application/json.
Content-TypeNot requiredNo request body is used for GET requests.
05/Examples
EXAMPLES

Request & Response Examples

Request Examples

cURL
curl -X GET "https://sylvatica.my.id/api/example?apikey=YOUR_API_KEY"
JavaScript (fetch)
const response = await fetch("https://sylvatica.my.id/api/example?apikey=YOUR_API_KEY");
const data = await response.json();
console.log(data);
Python
import requests

response = requests.get(
    "https://sylvatica.my.id/api/example",
    params={"apikey": "YOUR_API_KEY"}
)
data = response.json()
print(data)
Go
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	resp, err := http.Get("https://sylvatica.my.id/api/example?apikey=YOUR_API_KEY")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer resp.Body.Close()

	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)
	fmt.Println(result)
}

Response Examples

Successful requests return status: true with the payload inside result:

200 OK
{
  "status": true,
  "creator": "Dandy",
  "result": {
    "message": "Hello from KuroNeko API"
  }
}

Failed requests return status: false with a clear, readable message:

429 Too Many Requests
{
  "status": false,
  "creator": "Dandy",
  "message": "Daily limit reached. Try again after reset at 00:00 WIB."
}

If your API key has been banned by an Admin (for example, for spamming an endpoint), the server responds with a 403 Forbidden and includes a ban_reason field:

403 Forbidden (Banned)
{
  "ban_reason": "spam endpoint",
  "creator": "Dandy",
  "message": "Akun Anda telah dibanned oleh Admin",
  "status": false
}

Usage Examples

A typical pattern for handling a bot command with KuroNeko API:

JavaScript: WhatsApp Bot Handler
async function handleCommand(sock, chatId, text) {
  const response = await fetch(
    `https://sylvatica.my.id/api/example?apikey=${process.env.KURONEKO_API_KEY}&text=${encodeURIComponent(text)}`
  );
  const data = await response.json();
  if (data.status) {
    await sock.sendMessage(chatId, { text: data.result.message });
  } else {
    await sock.sendMessage(chatId, { text: `Error: ${data.message}` });
  }
}
06/Errors
ERRORS

Error Responses

StatusMeaningCommon Cause
200OKRequest succeeded.
400Bad RequestA required parameter is missing or invalid.
401UnauthorizedNo API key was provided.
403ForbiddenAPI key is invalid, revoked, banned by Admin, or the endpoint requires a higher tier.
404Not FoundThe endpoint path doesn't exist.
429Too Many RequestsDaily quota reached, or more than 10 requests/second from the same IP.
500Internal Server ErrorUnexpected error on the server.
07/Rate Limits
LIMITS

Rate Limits

Your daily request limit depends on your API key's tier:

60/day
Common
100/day
Starter
200/day
Silver
300/day
Gold
500/day
Platinum
1000/day
Ultra
2000/day
Ultimate
Daily reset: all usage counters reset automatically at 00:00 WIB, regardless of tier.
Burst protection: more than 10 requests in 1 second from the same IP triggers an automatic ban lasting 10 seconds.
Account banned: an Admin can ban an API key manually (e.g. for spamming an endpoint). Banned requests return 403 Forbidden with a ban_reason explaining why.
Expired paid tier: when a paid plan expires, the key is automatically downgraded back to Common. Upgrade anytime at /shop.
08/Troubleshooting
TROUBLE

Common Troubleshooting

Getting 401 Unauthorized? Make sure your API key is included as ?apikey=, ?key=, or the X-API-Key header on every request.
Getting 429 Too Many Requests? You've either hit your daily quota (wait for the 00:00 WIB reset or upgrade at /shop) or you're sending requests too quickly (wait a few seconds).
Getting 403 with a ban_reason? Your API key has been banned by an Admin. Check the ban_reason field in the response for details, or contact support via /feedback.
Getting 404 on an endpoint you copied? Verify the base URL and path against the exact listing in the sidebar. Endpoint paths are case sensitive.
CORS error in the browser? If you're calling the API directly from JavaScript running in the browser, route the request through your own backend server instead of calling it straight from the browser.
09/FAQ
FAQ

FAQ

KuroNeko API adalah layanan REST API bertenaga Golang yang menyediakan berbagai macam endpoint dengan response berupa JSON standar, dibuat agar mudah diintegrasikan ke aplikasi apapun.
Login menggunakan akun Google atau GitHub lewat tombol "Sign In". Setelah login, API Key otomatis dibuatkan dan bisa dilihat di halaman profil kamu, dengan paket default Common (limit 60/hari).
Ada 7 tier: Common (gratis, limit 60/hari), Starter (limit 100/hari), Silver (limit 200/hari), Gold (limit 300/hari), Platinum (limit 500/hari), Ultra (limit 1000/hari), dan Ultimate (limit 2000/hari). Tier Gold ke atas mendapatkan akses endpoint premium.
Semua API Key otomatis direset pemakaian hariannya (usage) setiap jam 00:00 WIB, tanpa terkecuali dari tier manapun.
Server akan menolak request dengan status 429 (Too Many Requests) dan pesan bahwa limit harian telah habis, sampai limit direset otomatis jam 00:00 WIB.
Sertakan API Key kamu sebagai query parameter ?apikey=YOUR_KEY (atau ?key=YOUR_KEY), atau lewat header X-API-Key.
Ada proteksi rate limit per IP: lebih dari 10 request dalam 1 detik akan membuat IP tersebut dibanned otomatis selama 10 detik untuk menjaga stabilitas server.
API Key otomatis diturunkan (downgrade) kembali ke paket Common dengan limit 60/hari secara otomatis, tanpa perlu tindakan manual.
Admin dapat memban API Key secara manual jika terdeteksi menyalahgunakan layanan, misalnya spam endpoint. Response akan berupa 403 Forbidden berisi status: false dan field ban_reason yang menjelaskan alasannya.

Fetching data...