const url = 'https://www.example.com';
const apiUrl = 'https://platform.lemino.ai/api/url2md/' + url;

const response = await fetch(apiUrl, {
  method: 'GET',
  headers: {
    'x-api-key': 'YOUR_API_KEY',
    'x-extract-images': 'no',
    'accept': 'text/plain'
  }
});

const markdown = await response.text();
console.log(markdown);

import requests

url = 'https://www.example.com'
api_url = 'https://platform.lemino.ai/api/url2md/' + url

headers = {
    'x-api-key': 'YOUR_API_KEY',
    'x-extract-images': 'no',
    'accept': 'text/plain'
}

response = requests.get(api_url, headers=headers)
markdown = response.text

print(markdown)

<?php

$url = 'https://www.example.com';
$api_url = 'https://platform.lemino.ai/api/url2md/' . $url;

$headers = [
    'x-api-key: YOUR_API_KEY',
    'x-extract-images: no',
    'accept: text/plain'
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $api_url);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

echo $response;

?>

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://www.example.com"
    apiUrl := "https://platform.lemino.ai/api/url2md/" + url
    
    req, _ := http.NewRequest("GET", apiUrl, nil)
    req.Header.Add("x-api-key", "YOUR_API_KEY")
    req.Header.Add("x-extract-images", "no")
    req.Header.Add("accept", "text/plain")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

require 'net/http'
require 'uri'

url = 'https://www.example.com'
api_url = 'https://platform.lemino.ai/api/url2md/' + url

uri = URI(api_url)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['x-api-key'] = 'YOUR_API_KEY'
request['x-extract-images'] = 'no'
request['accept'] = 'text/plain'

response = http.request(request)
puts response.body

import java.net.http.*;
import java.net.URI;

public class ApiClient {
    public static void main(String[] args) throws Exception {
        String url = "https://www.example.com";
        String apiUrl = "https://platform.lemino.ai/api/url2md/" + url;
        
        HttpClient client = HttpClient.newHttpClient();
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(apiUrl))
                .header("x-api-key", "YOUR_API_KEY")
                .header("x-extract-images", "no")
                .header("accept", "text/plain")
                .build();
        
        HttpResponse<String> response = client.send(request, 
                HttpResponse.BodyHandlers.ofString());
        
        System.out.println(response.body());
    }
}

import okhttp3.*
import java.io.IOException

fun main() {
    val url = "https://example.com"
    val apiUrl = "https://platform.lemino.ai/api/url2md/" + url
    
    val client = OkHttpClient.Builder()
        .connectTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
        .readTimeout(60, java.util.concurrent.TimeUnit.SECONDS)
        .writeTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
        .build()
    
    val request = Request.Builder()
        .url(apiUrl)
        .addHeader("x-api-key", "YOUR_API_KEY")
        .addHeader("x-extract-images", "no")
        .addHeader("accept", "text/plain")
        .build()
    
    val response = client.newCall(request).execute()
    println(response.body?.string())
}

import Foundation

let url = "https://example.com"
let apiUrl = "https://platform.lemino.ai/api/url2md/" + url

guard let requestUrl = URL(string: apiUrl) else {
    print("Invalid URL")
    exit(1)
}

var request = URLRequest(url: requestUrl)
request.httpMethod = "GET"
request.setValue("YOUR_API_KEY", forHTTPHeaderField: "x-api-key")
request.setValue("no", forHTTPHeaderField: "x-extract-images")
request.setValue("text/plain", forHTTPHeaderField: "accept")

let semaphore = DispatchSemaphore(value: 0)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
    } else if let data = data, let result = String(data: data, encoding: .utf8) {
        print(result)
    }
    semaphore.signal()
}

task.resume()
semaphore.wait()

#include <iostream>
#include <string>
#include <curl/curl.h>

size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* response) {
    size_t totalSize = size * nmemb;
    response->append((char*)contents, totalSize);
    return totalSize;
}

int main() {
    std::string url = "https://example.com";
    std::string apiUrl = "https://platform.lemino.ai/api/url2md/" + url;
    
    CURL* curl;
    CURLcode res;
    std::string response;
    
    curl = curl_easy_init();
    if(curl) {
        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "x-api-key: YOUR_API_KEY");
        headers = curl_slist_append(headers, "x-extract-images: no");
        headers = curl_slist_append(headers, "accept: text/plain");
        
        curl_easy_setopt(curl, CURLOPT_URL, apiUrl.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
        
        res = curl_easy_perform(curl);
        
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    
    std::cout << response << std::endl;
    return 0;
}

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

class Program
{
    static async Task Main(string[] args)
    {
        string url = "https://example.com";
        string apiUrl = "https://platform.lemino.ai/api/url2md/" + url;
        
        using var client = new HttpClient();
        
        client.DefaultRequestHeaders.Add("x-api-key", "YOUR_API_KEY");
        client.DefaultRequestHeaders.Add("x-extract-images", "no");
        client.DefaultRequestHeaders.Add("accept", "text/plain");
        
        try
        {
            var response = await client.GetAsync(apiUrl);
            
            string result = await response.Content.ReadAsStringAsync();
            Console.WriteLine(result);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}