Leads - List By Page

curl --request GET 'https://api.beladed.dev/api/pages/leads/all?pageId=id_demo_001' \
  --header 'Accept: application/json'

const response = await fetch("https://api.beladed.dev/api/pages/leads/all?pageId=id_demo_001", {
  method: "GET",
  headers: {
  "Accept": "application/json"
}
});
if (!response.ok) throw new Error(`Beladed request failed: ${response.status}`);
const responseText = await response.text();
const data = responseText ? JSON.parse(responseText) : null;

import json
import requests

response = requests.request(
    "GET",
    "https://api.beladed.dev/api/pages/leads/all?pageId=id_demo_001",
    headers={"Accept":"application/json"},
    timeout=30,
)
response.raise_for_status()
data = response.json()

<?php
$client = curl_init('https://api.beladed.dev/api/pages/leads/all?pageId=id_demo_001');
curl_setopt_array($client, [
  CURLOPT_CUSTOMREQUEST => 'GET',
  CURLOPT_HTTPHEADER => ['Accept: application/json'],
  CURLOPT_RETURNTRANSFER => true,
]);
$response = curl_exec($client);
if ($response === false) throw new RuntimeException(curl_error($client));
curl_close($client);
$data = $response === "" ? null : json_decode($response, true, 512, JSON_THROW_ON_ERROR);

require "net/http"
require "json"

uri = URI('https://api.beladed.dev/api/pages/leads/all?pageId=id_demo_001')
request = Net::HTTP::Get.new(uri)
request['Accept'] = 'application/json'
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(request) }
raise "Beladed request failed: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
data = response.body.empty? ? nil : JSON.parse(response.body)

public class BeladedExample {
  public static void main(String[] args) throws Exception {
    var request = java.net.http.HttpRequest.newBuilder()
        .uri(java.net.URI.create("https://api.beladed.dev/api/pages/leads/all?pageId=id_demo_001"))
        .header("Accept", "application/json")
        .method("GET", java.net.http.HttpRequest.BodyPublishers.noBody())
        .build();
    var response = java.net.http.HttpClient.newHttpClient().send(request, java.net.http.HttpResponse.BodyHandlers.ofString());
    if (response.statusCode() >= 400) throw new IllegalStateException("Beladed request failed: " + response.statusCode());
    var responseJson = response.body();
    System.out.println(responseJson);
  }
}

package main

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

func callBeladed() (any, error) {
  body := []byte("")
  request, err := http.NewRequest("GET", "https://api.beladed.dev/api/pages/leads/all?pageId=id_demo_001", bytes.NewReader(body))
  if err != nil { return nil, err }
  request.Header.Set("Accept", "application/json")
  response, err := http.DefaultClient.Do(request)
  if err != nil { return nil, err }
  defer response.Body.Close()
  if response.StatusCode >= 400 { return nil, fmt.Errorf("Beladed request failed: %s", response.Status) }
  var data any
  if err := json.NewDecoder(response.Body).Decode(&data); err != nil && err != io.EOF { return nil, err }
  return data, nil
}

func main() {
  data, err := callBeladed()
  if err != nil { panic(err) }
  fmt.Printf("%#v\n", data)
}

using System.Net.Http;

using var client = new HttpClient();
using var request = new HttpRequestMessage(new HttpMethod("GET"), "https://api.beladed.dev/api/pages/leads/all?pageId=id_demo_001");
request.Headers.TryAddWithoutValidation("Accept", "application/json");
using var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync();
using var data = System.Text.Json.JsonDocument.Parse(string.IsNullOrWhiteSpace(responseBody) ? "null" : responseBody);

import Foundation

var request = URLRequest(url: URL(string: "https://api.beladed.dev/api/pages/leads/all?pageId=id_demo_001")!)
request.httpMethod = "GET"
request.setValue("application/json", forHTTPHeaderField: "Accept")
let (data, response) = try await URLSession.shared.data(for: request)
guard let httpResponse = response as? HTTPURLResponse, (200..<300).contains(httpResponse.statusCode) else { throw URLError(.badServerResponse) }
let decoded: Any? = data.isEmpty ? nil : (try JSONSerialization.jsonObject(with: data))

fun main() {
  val request = okhttp3.Request.Builder()
    .url("https://api.beladed.dev/api/pages/leads/all?pageId=id_demo_001")
    .addHeader("Accept", "application/json")
    .method("GET", null)
    .build()
  val responseJson = okhttp3.OkHttpClient().newCall(request).execute().use { response ->
    check(response.isSuccessful) { "Beladed request failed: ${response.code}" }
    response.body?.string().orEmpty()
  }
  println(responseJson)
}