POST channelUnfollow Unfollow a channel

<?php

$payload = [
    'instanceid' => 'YOUR_INSTANCE_ID',
    'token' => 'YOUR_INSTANCE_TOKEN',
    'channelId' => '120363000000000000@newsletter',
];

$ch = curl_init();

curl_setopt_array($ch, [
    CURLOPT_URL            => 'https://api.replier.net/channelUnfollow',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => http_build_query($payload),
]);

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

if ($error !== '') {
    throw new RuntimeException($error);
}

$result = json_decode($response, true);

// Every endpoint answers with {"success": bool, "msg": [...]} on failure.
if (isset($result['success']) && $result['success'] === false) {
    throw new RuntimeException('API error ' . implode(', ', $result['msg']));
}

print_r($result);

import requests

url = 'https://api.replier.net/channelUnfollow'
payload = {
    'instanceid': 'YOUR_INSTANCE_ID',
    'token': 'YOUR_INSTANCE_TOKEN',
    'channelId': '120363000000000000@newsletter',
}

response = requests.post(url, data=payload, timeout=30)
response.raise_for_status()

result = response.json()

if result.get('success') is False:
    raise RuntimeError('API error: %s' % result.get('msg'))

print(result)

const url = 'https://api.replier.net/channelUnfollow';

const payload = new URLSearchParams({
  instanceid: 'YOUR_INSTANCE_ID',
  token: 'YOUR_INSTANCE_TOKEN',
  channelId: '120363000000000000@newsletter',
});

const response = await fetch(url, {
  method: 'POST',
  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
  body: payload,
});

const result = await response.json();

if (result.success === false) {
  throw new Error(`API error: ${result.msg.join(', ')}`);
}

console.log(result);

const axios = require('axios');

const payload = new URLSearchParams({
  instanceid: 'YOUR_INSTANCE_ID',
  token: 'YOUR_INSTANCE_TOKEN',
  channelId: '120363000000000000@newsletter',
});

(async () => {
  try {
    const { data } = await axios.post('https://api.replier.net/channelUnfollow', payload, { timeout: 30000 });

    if (data.success === false) {
      throw new Error(`API error: ${data.msg.join(', ')}`);
    }

    console.log(data);
  } catch (err) {
    console.error(err.message);
  }
})();

$.ajax({
  url: 'https://api.replier.net/channelUnfollow',
  method: 'POST',
  data: {
    instanceid: 'YOUR_INSTANCE_ID',
    token: 'YOUR_INSTANCE_TOKEN',
    channelId: '120363000000000000@newsletter',
  },
  dataType: 'json',
})
  .done(function (result) {
    if (result.success === false) {
      console.error('API error: ' + result.msg.join(', '));
      return;
    }

    console.log(result);
  })
  .fail(function (xhr) {
    console.error(xhr.status, xhr.responseText);
  });

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

class Program
{
    static readonly HttpClient client = new HttpClient();

    static async Task Main()
    {
        var payload = new Dictionary<string, string>
        {
            { "instanceid", "YOUR_INSTANCE_ID" },
            { "token", "YOUR_INSTANCE_TOKEN" },
            { "channelId", "120363000000000000@newsletter" },
        };

        var response = await client.PostAsync("https://api.replier.net/channelUnfollow", new FormUrlEncodedContent(payload));
        response.EnsureSuccessStatusCode();

        var body = await response.Content.ReadAsStringAsync();
        Console.WriteLine(body);
    }
}

import java.io.IOException;
import okhttp3.*;

public class Example {
    public static void main(String[] args) throws IOException {
        OkHttpClient client = new OkHttpClient();

        FormBody.Builder form = new FormBody.Builder();
        form.add("instanceid", "YOUR_INSTANCE_ID");
        form.add("token", "YOUR_INSTANCE_TOKEN");
        form.add("channelId", "120363000000000000@newsletter");

        Request request = new Request.Builder()
                .url("https://api.replier.net/channelUnfollow")
                .post(form.build())
                .build();

        try (Response response = client.newCall(request).execute()) {
            System.out.println(response.body().string());
        }
    }
}

require 'net/http'
require 'json'
require 'uri'

uri = URI('https://api.replier.net/channelUnfollow')

response = Net::HTTP.post_form(uri, {
  'instanceid' => 'YOUR_INSTANCE_ID',
  'token' => 'YOUR_INSTANCE_TOKEN',
  'channelId' => '120363000000000000@newsletter',
})

result = JSON.parse(response.body)

raise "API error: #{result['msg'].join(', ')}" if result['success'] == false

puts result

package main

import (
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strings"
)

func main() {
	form := url.Values{}
	form.Set("instanceid", "YOUR_INSTANCE_ID")
	form.Set("token", "YOUR_INSTANCE_TOKEN")
	form.Set("channelId", "120363000000000000@newsletter")

	resp, err := http.Post(
		"https://api.replier.net/channelUnfollow",
		"application/x-www-form-urlencoded",
		strings.NewReader(form.Encode()),
	)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(body))
}