Unlock Your Free ChatGPT API Access Today—No Cost, No Hassle

            
                 Copy Code
            
            
const axios = require('axios');
const qs = require('querystring');

// Define the prompt to be sent
const prompt = 'Please generate a simple blog post according to this title "What is CHATGPT"';

// Enter E-mail to generate API
const apiKey = 'Enter your E-mail Address to get the free ChatGPT API';

// Define the default model if none is specified
const defaultModel = 'gpt-3.5-turbo';

// Uncomment the model you want to use, and comment out the others
// const model = 'gpt-4';
// const model = 'gpt-4-32k';
// const model = 'gpt-3.5-turbo-0125';
const model = defaultModel;

// Build the URL to call
const apiUrl = `http://195.179.229.119/gpt/api.php?${qs.stringify({
  prompt: prompt,
  api_key: apiKey,
  model: model
})}`;

// Execute the HTTP request
axios.get(apiUrl)
  .then(response => {
    // Print the response data
    console.log(response.data);
  })
  .catch(error => {
    // Print any errors
    console.error('Request Error:', error.message);
  });
            
        

            
                 Copy Code
            
            
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;

public class ChatGPTRequest {
    public static void main(String[] args) {
        try {
            // Define the prompt to be sent
            String prompt = "Please generate a simple blog post according to this title \"What is CHATGPT\"";

            // Enter E-mail to generate API
            String apiKey = "Enter your E-mail Address to get the free ChatGPT API";

            // Define the default model if none is specified
            String defaultModel = "gpt-3.5-turbo";

            // Uncomment the model you want to use, and comment out the others
            // String model = "gpt-4";
            // String model = "gpt-4-32k";
            // String model = "gpt-3.5-turbo-0125";
            String model = defaultModel;

            // Build the URL to call
            String apiUrl = "http://195.179.229.119/gpt/api.php?" + 
                "prompt=" + URLEncoder.encode(prompt, "UTF-8") + 
                "&api_key=" + URLEncoder.encode(apiKey, "UTF-8") + 
                "&model=" + URLEncoder.encode(model, "UTF-8");

            // Create URL object
            URL url = new URL(apiUrl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setRequestProperty("Accept", "application/json");

            // Get the response
            BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();

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

            // Print the response
            System.out.println(response.toString());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

            
        

            
                 Copy Code
            
            
using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web;

class Program
{
    static async Task Main()
    {
        // Define the prompt to be sent
        string prompt = "Please generate a simple blog post according to this title \"What is CHATGPT\"";

        // Enter E-mail to generate API
        string apiKey = "Enter your E-mail Address to get the free ChatGPT API";

        // Define the default model if none is specified
        string defaultModel = "gpt-3.5-turbo";

        // Uncomment the model you want to use, and comment out the others
        // string model = "gpt-4";
        // string model = "gpt-4-32k";
        // string model = "gpt-3.5-turbo-0125";
        string model = defaultModel;

        // Build the URL to call
        string apiUrl = $"http://195.179.229.119/gpt/api.php?prompt={HttpUtility.UrlEncode(prompt)}&api_key={HttpUtility.UrlEncode(apiKey)}&model={HttpUtility.UrlEncode(model)}";

        // Initialize HttpClient
        using (HttpClient client = new HttpClient())
        {
            try
            {
                // Send the GET request
                HttpResponseMessage response = await client.GetAsync(apiUrl);
                
                // Check if the request was successful
                response.EnsureSuccessStatusCode();

                // Read the response as a string
                string responseBody = await response.Content.ReadAsStringAsync();
                
                // Print the response
                Console.WriteLine(responseBody);
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine($"Request error: {e.Message}");
            }
        }
    }
}

            
        

            
                 Copy Code
            
            
<?php
// Define the prompt to be sent
$prompt = 'Please generate a simple blog post according to this title "What is CHATGPT"';

// Enter E-mail to generate API
$apiKey = 'Enter your E-mail Address to get the free ChatGPT API';

// Define the default model if none is specified
$defaultModel = 'gpt-3.5-turbo';

// Uncomment the model you want to use, and comment out the others
// $model = 'gpt-4';
// $model = 'gpt-4-32k';
// $model = 'gpt-3.5-turbo-0125';
$model = $defaultModel;

// Build the URL to call
$apiUrl = 'http://195.179.229.119/gpt/api.php?prompt=' . urlencode($prompt) . '&api_key=' . urlencode($apiKey) . '&model=' . urlencode($model);

// Initialize cURL session
$ch = curl_init();

// Set cURL options
curl_setopt($ch, CURLOPT_URL, $apiUrl);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

// Execute the cURL request
$response = curl_exec($ch);

// Check for cURL errors
if ($response === false) {
    echo 'cURL Error: ' . htmlspecialchars(curl_error($ch));
} else {
    $data = json_decode($response, true);
    print_r($data);
}

// Close the cURL session
curl_close($ch);
?>
            
        

            
                 Copy Code
            
            
require 'net/http'
require 'uri'
require 'json'

# Define the prompt to be sent
prompt = 'Please generate a simple blog post according to this title "What is CHATGPT"'

# Enter E-mail to generate API
api_key = 'Enter your E-mail Address to get the free ChatGPT API'

# Define the default model if none is specified
default_model = 'gpt-3.5-turbo'

# Uncomment the model you want to use, and comment out the others
# model = 'gpt-4'
# model = 'gpt-4-32k'
# model = 'gpt-3.5-turbo-0125'
model = default_model

# Build the URL to call
uri = URI("http://195.179.229.119/gpt/api.php")
params = {
  'prompt' => prompt,
  'api_key' => api_key,
  'model' => model
}
uri.query = URI.encode_www_form(params)

# Initialize Net::HTTP
response = Net::HTTP.get_response(uri)

# Check for response and handle errors
if response.is_a?(Net::HTTPSuccess)
  data = JSON.parse(response.body)
  puts data
else
  puts "HTTP Error: #{response.code} #{response.message}"
end

            
        

            
                 Copy Code
            
            
package main

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

func main() {
    // Define the prompt to be sent
    prompt := "Please generate a simple blog post according to this title \"What is CHATGPT\""

    // Enter E-mail to generate API
    apiKey := "Enter your E-mail Address to get the free ChatGPT API"

    // Define the default model if none is specified
    defaultModel := "gpt-3.5-turbo"

    // Uncomment the model you want to use, and comment out the others
    // model := "gpt-4"
    // model := "gpt-4-32k"
    // model := "gpt-3.5-turbo-0125"
    model := defaultModel

    // Build the URL to call
    apiUrl := "http://195.179.229.119/gpt/api.php"
    params := url.Values{}
    params.Add("prompt", prompt)
    params.Add("api_key", apiKey)
    params.Add("model", model)

    // Send HTTP GET request
    resp, err := http.Get(fmt.Sprintf("%s?%s", apiUrl, params.Encode()))
    if err != nil {
        log.Fatalf("HTTP Error: %s", err)
    }
    defer resp.Body.Close()

    // Check if response is successful
    if resp.StatusCode != http.StatusOK {
        log.Fatalf("HTTP Error: %s", resp.Status)
    }

    // Parse JSON response
    var data map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
        log.Fatalf("JSON Error: %s", err)
    }

    // Print the data
    fmt.Println(data)
}

            
        

            
                 Copy Code
            
            
import Foundation

// Define the prompt to be sent
let prompt = "Please generate a simple blog post according to this title \"What is CHATGPT\""

// Enter E-mail to generate API
let apiKey = "Enter your E-mail Address to get the free ChatGPT API"

// Define the default model if none is specified
let defaultModel = "gpt-3.5-turbo"

// Uncomment the model you want to use, and comment out the others
// let model = "gpt-4"
// let model = "gpt-4-32k"
// let model = "gpt-3.5-turbo-0125"
let model = defaultModel

// Build the URL to call
let apiUrl = "http://195.179.229.119/gpt/api.php"
var urlComponents = URLComponents(string: apiUrl)!
urlComponents.queryItems = [
    URLQueryItem(name: "prompt", value: prompt),
    URLQueryItem(name: "api_key", value: apiKey),
    URLQueryItem(name: "model", value: model)
]

let url = urlComponents.url!

// Create the URL request
var request = URLRequest(url: url)
request.httpMethod = "GET"

// Create a URL session
let session = URLSession.shared

// Perform the HTTP GET request
let task = session.dataTask(with: request) { data, response, error in
    if let error = error {
        print("HTTP Error: \(error.localizedDescription)")
        return
    }
    
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        print("HTTP Error: Response status code is not 200")
        return
    }
    
    guard let data = data else {
        print("HTTP Error: No data received")
        return
    }
    
    // Parse JSON response
    do {
        if let json = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
            print(json)
        } else {
            print("JSON Error: Unable to parse JSON")
        }
    } catch {
        print("JSON Error: \(error.localizedDescription)")
    }
}

// Start the data task
task.resume()
            
        

            
                 Copy Code
            
            
#include 
#include 
#include 
#include 

// Write callback function for libcurl to handle response data
size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    // Define the prompt to be sent
    std::string prompt = "Please generate a simple blog post according to this title \"What is CHATGPT\"";

    // Enter E-mail to generate API
    std::string apiKey = "Enter your E-mail Address to get the free ChatGPT API";

    // Define the default model if none is specified
    std::string defaultModel = "gpt-3.5-turbo";

    // Uncomment the model you want to use, and comment out the others
    // std::string model = "gpt-4";
    // std::string model = "gpt-4-32k";
    // std::string model = "gpt-3.5-turbo-0125";
    std::string model = defaultModel;

    // Build the URL to call
    std::string apiUrl = "http://195.179.229.119/gpt/api.php?prompt=" + curl_easy_escape(nullptr, prompt.c_str(), prompt.length()) +
                         "&api_key=" + curl_easy_escape(nullptr, apiKey.c_str(), apiKey.length()) +
                         "&model=" + curl_easy_escape(nullptr, model.c_str(), model.length());

    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_ALL);
    curl = curl_easy_init();
    
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, apiUrl.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
        
        res = curl_easy_perform(curl);
        
        if (res != CURLE_OK) {
            std::cerr << "cURL Error: " << curl_easy_strerror(res) << std::endl;
        } else {
            try {
                auto json = nlohmann::json::parse(readBuffer);
                std::cout << json.dump(4) << std::endl; // Pretty print JSON
            } catch (nlohmann::json::parse_error& e) {
                std::cerr << "JSON Parse Error: " << e.what() << std::endl;
            }
        }
        
        curl_easy_cleanup(curl);
    }
    
    curl_global_cleanup();
    return 0;
}

            
        

            
                 Copy Code
            
            
library(httr)
library(jsonlite)

# Define the prompt to be sent
prompt <- "Please generate a simple blog post according to this title \"What is CHATGPT\""

# Enter E-mail to generate API
apiKey <- "Enter your E-mail Address to get the free ChatGPT API"

# Define the default model if none is specified
defaultModel <- "gpt-3.5-turbo"

# Uncomment the model you want to use, and comment out the others
# model <- "gpt-4"
# model <- "gpt-4-32k"
# model <- "gpt-3.5-turbo-0125"
model <- defaultModel

# Build the URL to call
apiUrl <- paste0("http://195.179.229.119/gpt/api.php?prompt=", URLencode(prompt),
                  "&api_key=", URLencode(apiKey),
                  "&model=", URLencode(model))

# Perform the HTTP request
response <- GET(apiUrl)

# Check if the request was successful
if (status_code(response) == 200) {
  # Parse and print the JSON response
  data <- fromJSON(content(response, "text", encoding = "UTF-8"))
  print(data)
} else {
  # Print error message
  cat("HTTP Error:", status_code(response), "\n")
}

            
        

            
                 Copy Code
            
            
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import com.google.gson.Gson

fun main() {
    // Define the prompt to be sent
    val prompt = "Please generate a simple blog post according to this title \"What is CHATGPT\""

    // Enter E-mail to generate API
    val apiKey = "Enter your E-mail Address to get the free ChatGPT API"

    // Define the default model if none is specified
    val defaultModel = "gpt-3.5-turbo"

    // Uncomment the model you want to use, and comment out the others
    // val model = "gpt-4"
    // val model = "gpt-4-32k"
    // val model = "gpt-3.5-turbo-0125"
    val model = defaultModel

    // Build the URL to call
    val apiUrl = "http://195.179.229.119/gpt/api.php?prompt=${encodeURIComponent(prompt)}&api_key=${encodeURIComponent(apiKey)}&model=${encodeURIComponent(model)}"

    // Initialize OkHttpClient
    val client = OkHttpClient()

    // Build the request
    val request = Request.Builder()
        .url(apiUrl)
        .build()

    // Execute the request
    try {
        val response: Response = client.newCall(request).execute()
        if (response.isSuccessful) {
            val responseData = response.body?.string()
            val data = Gson().fromJson(responseData, Map::class.java)
            println(data)
        } else {
            println("HTTP Error: ${response.code}")
        }
    } catch (e: Exception) {
        println("Request failed: ${e.message}")
    }
}

// Function to URL-encode a string
fun encodeURIComponent(value: String): String {
    return java.net.URLEncoder.encode(value, "UTF-8")
}
            
        

            
                 Copy Code
            
            
use reqwest::Client;
use serde_json::Value;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box> {
    // Define the prompt to be sent
    let prompt = "Please generate a simple blog post according to this title \"What is CHATGPT\"";

    // Enter E-mail to generate API
    let api_key = "Enter your E-mail Address to get the free ChatGPT API";

    // Define the default model if none is specified
    let default_model = "gpt-3.5-turbo";

    // Uncomment the model you want to use, and comment out the others
    // let model = "gpt-4";
    // let model = "gpt-4-32k";
    // let model = "gpt-3.5-turbo-0125";
    let model = default_model;

    // Build the URL to call
    let api_url = format!(
        "http://195.179.229.119/gpt/api.php?prompt={}&api_key={}&model={}",
        urlencoding::encode(prompt),
        urlencoding::encode(api_key),
        urlencoding::encode(model)
    );

    // Initialize reqwest client
    let client = Client::new();

    // Send the request
    let response = client
        .get(&api_url)
        .send()
        .await?;

    // Check for response status and get response body
    if response.status().is_success() {
        let response_text = response.text().await?;
        let data: Value = serde_json::from_str(&response_text)?;

        // Print the data
        println!("{}", serde_json::to_string_pretty(&data)?);
    } else {
        println!("HTTP Error: {}", response.status());
    }

    Ok(())
}