WILLzzz Email API — Dokumentasi Endpoint Banding

GET Endpoint

Base URL

Berikut adalah URL endpoint lengkap yang digunakan untuk mengakses API Banding. Semua parameter dikirim melalui query string.

GET
https://wilz-api.web.id/api/banding ?apikey={apikey} &email={gmail} &app_pw={app_pw} &pesan={pesan}

Parameter

Query Parameters

Semua parameter berikut wajib dikirim sebagai query string. Pastikan semua parameter terisi dengan benar.

apikey Wajib

Kunci API autentikasi yang didapatkan dari developer WILLzzz Email API. Digunakan untuk verifikasi akses.

string • Sensitif

email Wajib

Alamat email Gmail yang akan digunakan untuk autentikasi. Pastikan menggunakan format email yang valid.

string • Format Email

app_pw Wajib

App Password dari Google yang di-generate melalui Google Account → Security → 2-Step Verification → App Passwords.

string • Sensitif

pesan Wajib

Pesan atau konten yang akan dikirim/diproses melalui endpoint Banding. Harus di-encode untuk karakter khusus.

string • URL Encoded

Response

Format Respons

API mengembalikan respons dalam format JSON. Berikut contoh respons saat berhasil dan saat terjadi error.

200 OK — Berhasil

{
  "status": true,
  "message": "Berhasil",
  "data": { ... }
}

401 / 403 — Error Autentikasi

{
  "status": false,
  "message": "Apikey tidak valid"
}

400 — Parameter Tidak Lengkap

{
  "status": false,
  "message": "Parameter tidak lengkap"
}

500 — Kesalahan Server

{
  "status": false,
  "message": "Terjadi kesalahan internal"
}

Integrasi

Contoh Kode

Copy dan paste kode di bawah sesuai bahasa pemrograman yang Anda gunakan. Ganti variabel placeholder dengan kredensial asli Anda.

JavaScript — Fetch API

// Konfigurasi
const APIKEY = "your_apikey_here";
const EMAIL = "your_email@gmail.com";
const APP_PW = "your_app_password";
const PESAN = "Halo, ini pesan test";

// Encode parameter
const params = new URLSearchParams({
  apikey: APIKEY,
  email: EMAIL,
  app_pw: APP_PW,
  pesan: PESAN
});

const url = `https://wilz-api.web.id/api/banding?${params}`;

// Kirim request
try {
  const response = await fetch(url);
  const data = await response.json();

  if (data.status) {
    console.log("✅ Berhasil:", data);
  } else {
    console.error("❌ Gagal:", data.message);
  }
} catch (error) {
  console.error("Error:", error);
}

Node.js — Native HTTP

const https = require('https');

// Konfigurasi
const APIKEY = 'your_apikey_here';
const EMAIL = 'your_email@gmail.com';
const APP_PW = 'your_app_password';
const PESAN = 'Halo, ini pesan test';

const params = new URLSearchParams({
  apikey: APIKEY,
  email: EMAIL,
  app_pw: APP_PW,
  pesan: PESAN
});

const url = `https://wilz-api.web.id/api/banding?${params}`;

https.get(url, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => {
    const result = JSON.parse(data);
    console.log(result);
  });
}).on('error', (err) => {
  console.error('Error:', err.message);
});

Node.js — Axios

const axios = require('axios');

const response = await axios.get('https://wilz-api.web.id/api/banding', {
  params: {
    apikey: 'your_apikey_here',
    email: 'your_email@gmail.com',
    app_pw: 'your_app_password',
    pesan: 'Halo, ini pesan test'
  }
});

console.log(response.data);

Python — Requests

import requests

# Konfigurasi
APIKEY = "your_apikey_here"
EMAIL = "your_email@gmail.com"
APP_PW = "your_app_password"
PESAN = "Halo, ini pesan test"

# Kirim request
url = "https://wilz-api.web.id/api/banding"
params = {
    "apikey": APIKEY,
    "email": EMAIL,
    "app_pw": APP_PW,
    "pesan": PESAN
}

response = requests.get(url, params=params)
data = response.json()

if data.get("status"):
    print(f"✅ Berhasil: {data}")
else:
    print(f"❌ Gagal: {data.get('message')}")

Python — http.client (Tanpa Library)

import urllib.parse
import urllib.request
import json

params = urllib.parse.urlencode({
    "apikey": "your_apikey_here",
    "email": "your_email@gmail.com",
    "app_pw": "your_app_password",
    "pesan": "Halo, ini pesan test"
})

url = f"https://wilz-api.web.id/api/banding?{params}"

with urllib.request.urlopen(url) as res:
    data = json.loads(res.read().decode())
    print(data)

PHP — file_get_contents

<?php

// Konfigurasi
$apikey = "your_apikey_here";
$email = "your_email@gmail.com";
$app_pw = "your_app_password";
$pesan = "Halo, ini pesan test";

// Bangun URL dengan parameter
$params = http_build_query([
    'apikey' => $apikey,
    'email'  => $email,
    'app_pw' => $app_pw,
    'pesan'  => $pesan
]);

$url = "https://wilz-api.web.id/api/banding?$params";

// Kirim request
$response = file_get_contents($url);
$data = json_decode($response, true);

if ($data['status']) {
    echo "✅ Berhasil: " . json_encode($data);
} else {
    echo "❌ Gagal: " . $data['message'];
}

PHP — cURL

<?php

$ch = curl_init();

$url = "https://wilz-api.web.id/api/banding?"
     . http_build_query([
         'apikey' => 'your_apikey_here',
         'email'  => 'your_email@gmail.com',
         'app_pw' => 'your_app_password',
         'pesan'  => 'Halo, ini pesan test'
     ]);

curl_setopt_array($ch, [
    CURLOPT_URL            => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

Go — net/http

package main

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

func main() {
    // Konfigurasi
    params := url.Values{}
    params.Set("apikey", "your_apikey_here")
    params.Set("email", "your_email@gmail.com")
    params.Set("app_pw", "your_app_password")
    params.Set("pesan", "Halo, ini pesan test")

    fullURL := "https://wilz-api.web.id/api/banding?" + params.Encode()

    // Kirim request
    resp, err := http.Get(fullURL)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    body, := io.ReadAll(resp.Body)

    var result map[string]interface{}
    json.Unmarshal(body, &result)
    fmt.Printf("%+v\n", result)
}

Java — HttpURLConnection

import java.net.URI;
import java.net.http.*;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class BandingApi {
    public static void main(String[] args) throws Exception {
        // Konfigurasi
        String apikey = "your_apikey_here";
        String email = "your_email@gmail.com";
        String appPw = "your_app_password";
        String pesan = "Halo, ini pesan test";

        // Encode parameter
        String params = String.format(
            "apikey=%s&email=%s&app_pw=%s&pesan=%s",
            encode(apikey), encode(email),
            encode(appPw),  encode(pesan)
        );

        String url = "https://wilz-api.web.id/api/banding?" + params;

        // Kirim request
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .GET()
            .build();

        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        System.out.println(response.body());
    }

    static String encode(String s) {
        return URLEncoder.encode(s, StandardCharsets.UTF_8);
    }
}

C# — HttpClient

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        // Konfigurasi
        var apikey = "your_apikey_here";
        var email = "your_email@gmail.com";
        var appPw = "your_app_password";
        var pesan = "Halo, ini pesan test";

        // Bangun URL
        var queryParams = FormUrlEncodedContent.Build(
            new[] {
                new KeyValuePair<string, string>("apikey", apikey),
                new KeyValuePair<string, string>("email", email),
                new KeyValuePair<string, string>("app_pw", appPw),
                new KeyValuePair<string, string>("pesan", pesan)
            }
        );

        var url = $"https://wilz-api.web.id/api/banding?{queryParams}";

        // Kirim request
        using var client = new HttpClient();
        var response = await client.GetStringAsync(url);

        Console.WriteLine(response);
    }
}

Rust — reqwest

// Cargo.toml: reqwest = { version = "0.11", features = ["json"] }
//              tokio = { version = "1", features = ["full"] }

use reqwest;
use std::collections::HashMap;

[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Konfigurasi
    let mut params = HashMap::new();
    params.insert("apikey", "your_apikey_here");
    params.insert("email", "your_email@gmail.com");
    params.insert("app_pw", "your_app_password");
    params.insert("pesan", "Halo, ini pesan test");

    // Kirim request
    let client = reqwest::Client::new();
    let response = client
        .get("https://wilz-api.web.id/api/banding")
        .query(&params)
        .send()
        .await?;

    let body: serde_json::Value = response.json().await?;
    println!("{:#?}", body);

    Ok(())
}

Ruby — Net::HTTP

require "net/http"
require "uri"
require "json"

# Konfigurasi
params = {
  apikey: "your_apikey_here",
  email:  "your_email@gmail.com",
  app_pw: "your_app_password",
  pesan:  "Halo, ini pesan test"
}

uri = URI.parse("https://wilz-api.web.id/api/banding")
uri.query = URI.encode_www_form(params)

# Kirim request
response = Net::HTTP.get(uri)
data = JSON.parse(response.body)

if data["status"]
  puts "✅ Berhasil: #{data}"
else
  puts "❌ Gagal: #{data['message']}"
end

Dart / Flutter — http

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<void> sendBanding() async {
  // Konfigurasi
  final params = {
    'apikey': 'your_apikey_here',
    'email': 'your_email@gmail.com',
    'app_pw': 'your_app_password',
    'pesan': 'Halo, ini pesan test',
  };

  final queryString = params.entries
      .map((e) => '${e.key}=${Uri.encodeComponent(e.value)}')
      .join('&');

  final url = Uri.parse(
      'https://wilz-api.web.id/api/banding?$queryString');

  // Kirim request
  final response = await http.get(url);
  final data = json.decode(response.body);

  if (data['status']) {
    print('✅ Berhasil: $data');
  } else {
    print('❌ Gagal: ${data['message']}');
  }
}

Kotlin — kotlinx.coroutines

import java.net.URL
import java.net.URLEncoder
import kotlinx.coroutines.*

suspend fun sendBanding() {
    // Konfigurasi
    val params = listOf(
        "apikey" to "your_apikey_here",
        "email"  to "your_email@gmail.com",
        "app_pw" to "your_app_password",
        "pesan"  to "Halo, ini pesan test"
    ).map { "${it.first}=${encode(it.second)}" }
     .joinToString("&")

    val url = "https://wilz-api.web.id/api/banding?$params"

    // Kirim request
    val response = withContext(Dispatchers.IO) {
        URL(url).readText()
    }

    println(response)
}

fun encode(s: String): String =
    URLEncoder.encode(s, "UTF-8")

fun main() = runBlocking {
    sendBanding()
}

Swift — URLSession

import Foundation

// Konfigurasi
let params: [String: String] = [
    "apikey": "your_apikey_here",
    "email":  "your_email@gmail.com",
    "app_pw": "your_app_password",
    "pesan":  "Halo, ini pesan test"
]

// Bangun URL
var components = URLComponents(string: "https://wilz-api.web.id/api/banding")!
components.queryItems = params.map {
    URLQueryItem(name: $0.key, value: $0.value)
}

// Kirim request
let task = URLSession.shared.dataTask(with: components.url!) { data, response, error in
    guard let data = data else { return }

    do {
        let json = try JSONSerialization.jsonObject(
            with: data, options: []
        )
        print(json)
    } catch {
        print("Error: \(error)")
    }
}

task.resume()

Quick Test

Test dengan cURL

Cara tercepat untuk menguji endpoint adalah menggunakan cURL langsung dari terminal Anda.

Terminal — cURL

curl "https://wilz-api.web.id/api/banding?apikey=your_apikey_here&email=your_email@gmail.com&app_pw=your_app_password&pesan=Halo%20ini%20test"

Best Practices

Tips Integrasi

Jangan Hardcode

Simpan apikey, email, dan app_pw di environment variable. Jangan pernah commit kredensial ke version control.

Tambahkan Timeout

Selalu set timeout pada HTTP request untuk mencegah aplikasi hang jika server tidak merespon.

Error Handling

Selalu tangani error response dari API. Cek field status sebelum memproses data.

Retry Logic

Implementasikan retry dengan exponential backoff untuk menangani error jaringan sementara (5xx).

URL Encoding

Pastikan parameter terutama pesan di-encode dengan benar untuk karakter spesial.

Rate Limiting

Hindari spam request. Tambahkan delay atau implementasikan queue system untuk bulk operations.

FAQ

Endpoint Banding