import requests

api_url = 'https://api.slpy.com/v1/search'
params = {
	'lat': 'example_lat',
	'lon': 'example_lon',
	'level': '10',
	'polygon': 'geojson',
	'country': 'example_country',
	'key': 'your_api_key'
}

response = requests.get(api_url, params=params)

if response.status_code == 200:
	print(response.json())
else:
	print('Error:', response.status_code)

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

api_url = 'https://api.slpy.com/v1/search'
params = {
  'lat' => 'example_lat',
  'lon' => 'example_lon',
  'level' => '10',
  'polygon' => 'geojson',
  'country' => 'example_country',
  'key' => 'your_api_key'
}

uri = URI.parse(api_url)
uri.query = URI.encode_www_form(params)

response = Net::HTTP.get_response(uri)

if response.code == '200'
  data = JSON.parse(response.body)
  puts data
else
  puts "Error: #{response.code}"
end

<?php
$apiUrl = 'https://api.slpy.com/v1/search';
$params = array(
  'lat' => 'example_lat',
  'lon' => 'example_lon',
  'level' => '10',
  'polygon' => 'geojson',
  'country' => 'example_country',
  'key' => 'your_api_key'
);

$query = http_build_query($params);
$url = $apiUrl . '?' . $query;

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);

if (curl_errno($ch)) {
  echo 'Error:' . curl_error($ch);
} else {
  $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

  if ($statusCode == 200) {
	$data = json_decode($response);
	print_r($data);
  } else {
	echo 'Error: ' . $statusCode;
  }
}

curl_close($ch);
?>

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class ApiExample {
  public static void main(String[] args) {
	String apiUrl = "https://api.slpy.com/v1/search";
	String params = "lat=example_lat&lon=example_lon&level=10&polygon=geojson&country=example_country&key=your_api_key";
	String url = apiUrl + "?" + params;

	try {
	  URL obj = new URL(url);
	  HttpURLConnection con = (HttpURLConnection) obj.openConnection();
	  con.setRequestMethod("GET");

	  int responseCode = con.getResponseCode();
	  if (responseCode == HttpURLConnection.HTTP_OK) {
		BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
		String inputLine;
		StringBuffer response = new StringBuffer();

		while ((inputLine = in.readLine()) != null) {
		  response.append(inputLine);
		}
		in.close();

		System.out.println(response.toString());
	  } else {
		System.out.println("Error: " + responseCode);
	  }
	} catch (IOException e) {
	  e.printStackTrace();
	}
  }
}

package main

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

func main() {
	apiUrl := "https://api.slpy.com/v1/search"
	params := url.Values{}
	params.Set("lat", "example_lat")
	params.Set("lon", "example_lon")
	params.Set("level", "10")
	params.Set("polygon", "geojson")
	params.Set("country", "example_country")
	params.Set("key", "your_api_key")

	resp, err := http.Get(fmt.Sprintf("%s?%s", apiUrl, params.Encode()))

	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	defer resp.Body.Close()

	if resp.StatusCode == http.StatusOK {
		bodyBytes, err := ioutil.ReadAll(resp.Body)
		if err {
			fmt.Printf("Error reading response body: %v\n", err)
			return
		}

		var data interface{}
		json.Unmarshal(bodyBytes, &data)
		fmt.Println(data)
	} else {
		fmt.Printf("Error: %d\n", resp.StatusCode)
	}
}

  

import React from 'react';

function fetchData(params) {
  const apiUrl = 'https://api.slpy.com/v1/search';
  
  fetch(`${apiUrl}?${params}`)
	.then(response => {
	  if (response.ok) {
		return response.json();
	  } else {
		throw new Error(`Error: ${response.status}`);
	  }
	})
	.then(data => {
	  console.log(data);
	})
	.catch(error => {
	  console.error(error);
	});
}

function App() {
  const params = new URLSearchParams({
	lat: 'example_lat',
	lon: 'example_lon',
	level: '10',
	polygon: 'geojson',
	country: 'example_country',
	key: 'your_api_key'
  });
  
  React.useEffect(() => {
	fetchData(params);
  }, []);

  return (
	<div>
	  Check your console for the API response.
	  </div>
  );
}

export default App;

}

import { Component, OnInit } from '@angular/core';

@Component({
  selector: 'app-root',
  template: `Check your console for the API response.`
})
export class AppComponent implements OnInit {
  ngOnInit() {
	this.fetchData();
  }

  fetchData() {
	const apiUrl = 'https://api.slpy.com/v1/search';
	const params = new URLSearchParams({
		lat: 'example_lat',
		lon: 'example_lon',
		level: '10',
		polygon: 'geojson',
		country: 'example_country',
		key: 'your_api_key'
	});

	fetch(`${apiUrl}?${params}`)
	  .then(response => {
		if (response.ok) {
		  return response.json();
		} else {
		  throw new Error(`Error: ${response.status}`);
		}
	  })
	  .then(data => {
		console.log(data);
	  })
	  .catch(error => {
		console.error(error);
	  });
  }
}

<template>
<div>Check your console for the API response.</div>
</template>

<script>
export default {
  created() {
	this.fetchData();
  },
  methods: {
	fetchData() {
	  const apiUrl = 'https://api.slpy.com/v1/search';
	  const params = new URLSearchParams({
		lat: 'example_lat',
		lon: 'example_lon',
		level: '10',
		polygon: 'geojson',
		country: 'example_country',
		key: 'your_api_key'
	  });

	  fetch(`${apiUrl}?${params}`)
		.then(response => {
		  if (response.ok) {
			return response.json();
		  } else {
			throw new Error(`Error: ${response.status}`);
		  }
		})
		.then(data => {
		  console.log(data);
		})
		.catch(error => {
		  console.error(error);
		});
	}
  }
}
</script>

<script>
  function fetchData(params) {
	const apiUrl = 'https://api.slpy.com/v1/search';

	fetch(`${apiUrl}?${params}`)
	  .then(response => {
		if (response.ok) {
		  return response.json();
		} else {
		  throw new Error(`Error: ${response.status}`);
		}
	  })
	  .then(data => {
		console.log(data);
	  })
	  .catch(error => {
		console.error(error);
	  });
  }

  const params = new URLSearchParams({
	lat: 'example_lat',
	lon: 'example_lon',
	level: '10',
	polygon: 'geojson',
	country: 'example_country',
	key: 'your_api_key'
  });

  fetchData(params);
</script>

<main>
  Check your console for the API response.
</main>

const fetchData = (params: URLSearchParams) => {
  const apiUrl = 'https://api.slpy.com/v1/search';

  fetch(`${apiUrl}?${params}`)
	.then(response => {
	  if (response.ok) {
		return response.json();
	  } else {
		throw new Error(`Error: ${response.status}`);
	  }
	})
	.then(data => {
	  console.log(data);
	})
	.catch(error => {
	  console.error(error);
	});
}

const params = new URLSearchParams({
	lat: 'example_lat',
	lon: 'example_lon',
	level: '10',
	polygon: 'geojson',
	country: 'example_country',
	key: 'your_api_key'
});

fetchData(params);

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

void fetchData() async {
  const apiUrl = 'https://api.slpy.com/v1/search';
  final params = {
	lat: 'example_lat',
	lon: 'example_lon',
	level: '10',
	polygon: 'geojson',
	country: 'example_country',
	key: 'your_api_key',
  };

  final uri = Uri.parse(apiUrl).replace(queryParameters: params);

  try {
	final response = await http.get(uri);
	if (response.statusCode == 200) {
	  final data = json.decode(response.body);
	  print(data);
	} else {
	  throw Exception('Error: ${response.statusCode}');
	}
  } catch (error) {
	print(error);
  }
}

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
	fetchData();

	return MaterialApp(
	  home: Scaffold(
		appBar: AppBar(
		  title: Text('API Fetch Example'),
		),
		body: Center(
		  child: Text('Check your console for the API response.'),
		),
	  ),
	);
  }
}