विकल्प 1: छवि URL का उपयोग

const response = await fetch('https://thegendai.com/api/v1/generate-description', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'your_api_key_here'
  },
  body: JSON.stringify({
    brand_description: 'हम प्रीमियम पर्यावरण-अनुकूल उत्पाद बनाते हैं जो स्थिरता को शैली के साथ जोड़ते हैं',
    audience: 'पर्यावरण-सचेत उपभोक्ता जो गुणवत्ता और स्थिरता को महत्व देते हैं',
    tone_voice: 'पेशेवर लेकिन सुलभ, गुणवत्ता और पर्यावरणीय लाभों पर जोर देते हुए',
    languages: ['english', 'spanish'],
    product: {
      name: 'बांस की पानी की बोतल',
      category: 'पर्यावरण-अनुकूल',
      price: '24.99',
      image_url: 'https://example.com/product-image.jpg'
    }
  })
});

const data = await response.json();
console.log(data);

विकल्प 2: Base64 छवि का उपयोग

// Convert file to base64
function fileToBase64(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.readAsDataURL(file);
    reader.onload = () => resolve(reader.result.split(',')[1]);
    reader.onerror = error => reject(error);
  });
}

// Usage with file input
const fileInput = document.getElementById('imageFile');
const file = fileInput.files[0];
const base64Image = await fileToBase64(file);

const response = await fetch('https://thegendai.com/api/v1/generate-description', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'your_api_key_here'
  },
  body: JSON.stringify({
    brand_description: 'हम प्रीमियम पर्यावरण-अनुकूल उत्पाद बनाते हैं जो स्थिरता को शैली के साथ जोड़ते हैं',
    audience: 'पर्यावरण-सचेत उपभोक्ता जो गुणवत्ता और स्थिरता को महत्व देते हैं',
    tone_voice: 'पेशेवर लेकिन सुलभ, गुणवत्ता और पर्यावरणीय लाभों पर जोर देते हुए',
    languages: ['english', 'spanish'],
    product: {
      name: 'बांस की पानी की बोतल',
      category: 'पर्यावरण-अनुकूल',
      price: '24.99',
      image_b64: base64Image
    }
  })
});

const data = await response.json();
console.log(data);

विकल्प 1: छवि URL का उपयोग

import requests

url = "https://thegendai.com/api/v1/generate-description"
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "your_api_key_here"
}
data = {
    "brand_description": "हम प्रीमियम पर्यावरण-अनुकूल उत्पाद बनाते हैं जो स्थिरता को शैली के साथ जोड़ते हैं",
    "audience": "पर्यावरण-सचेत उपभोक्ता जो गुणवत्ता और स्थिरता को महत्व देते हैं",
    "tone_voice": "पेशेवर लेकिन सुलभ, गुणवत्ता और पर्यावरणीय लाभों पर जोर देते हुए",
    "languages": ["english", "spanish"],
    "product": {
        "name": "बांस की पानी की बोतल",
        "category": "पर्यावरण-अनुकूल",
        "price": "24.99",
        "image_url": "https://example.com/product-image.jpg"
    }
}

response = requests.post(url, headers=headers, json=data)
result = response.json()
print(result)

विकल्प 2: Base64 छवि का उपयोग

import requests
import base64

# Read and encode image file
def encode_image_to_base64(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

url = "https://thegendai.com/api/v1/generate-description"
headers = {
    "Content-Type": "application/json",
    "X-API-Key": "your_api_key_here"
}

# Encode the image
image_b64 = encode_image_to_base64("path/to/your/image.jpg")

data = {
    "brand_description": "हम प्रीमियम पर्यावरण-अनुकूल उत्पाद बनाते हैं जो स्थिरता को शैली के साथ जोड़ते हैं",
    "audience": "पर्यावरण-सचेत उपभोक्ता जो गुणवत्ता और स्थिरता को महत्व देते हैं",
    "tone_voice": "पेशेवर लेकिन सुलभ, गुणवत्ता और पर्यावरणीय लाभों पर जोर देते हुए",
    "languages": ["english", "spanish"],
    "product": {
        "name": "बांस की पानी की बोतल",
        "category": "पर्यावरण-अनुकूल",
        "price": "24.99",
        "image_b64": image_b64
    }
}

response = requests.post(url, headers=headers, json=data)
result = response.json()
print(result)

<?php

$url = "https://thegendai.com/api/v1/generate-description";
$headers = [
    'Content-Type: application/json',
    'X-API-Key: your_api_key_here'
];

$data = [
    'brand_description' => 'हम प्रीमियम पर्यावरण-अनुकूल उत्पाद बनाते हैं जो स्थिरता को शैली के साथ जोड़ते हैं',
    'audience' => 'पर्यावरण-सचेत उपभोक्ता जो गुणवत्ता और स्थिरता को महत्व देते हैं',
    'tone_voice' => 'पेशेवर लेकिन सुलभ, गुणवत्ता और पर्यावरणीय लाभों पर जोर देते हुए',
    'languages' => ['english', 'spanish'],
    'product' => [
        'name' => 'बांस की पानी की बोतल',
        'category' => 'पर्यावरण-अनुकूल',
        'price' => '24.99',
        'image_url' => 'https://example.com/product-image.jpg'
    ]
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode === 200) {
    $result = json_decode($response, true);
    print_r($result);
} else {
    echo "Error: " . $response;
}

?>

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.ArrayNode;

public class TheGendaiAPIClient {
    private static final String API_URL = "https://thegendai.com/api/v1/generate-description";
    private static final String API_KEY = "your_api_key_here";

    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        ObjectMapper mapper = new ObjectMapper();

        // Create request payload
        ObjectNode payload = mapper.createObjectNode();
        payload.put("brand_description", "हम प्रीमियम पर्यावरण-अनुकूल उत्पाद बनाते हैं जो स्थिरता को शैली के साथ जोड़ते हैं");
        payload.put("audience", "पर्यावरण-सचेत उपभोक्ता जो गुणवत्ता और स्थिरता को महत्व देते हैं");
        payload.put("tone_voice", "पेशेवर लेकिन सुलभ, गुणवत्ता और पर्यावरणीय लाभों पर जोर देते हुए");

        ArrayNode languages = mapper.createArrayNode();
        languages.add("english");
        languages.add("spanish");
        payload.set("languages", languages);

        ObjectNode product = mapper.createObjectNode();
        product.put("name", "बांस की पानी की बोतल");
        product.put("category", "पर्यावरण-अनुकूल");
        product.put("price", "24.99");
        product.put("image_url", "https://example.com/product-image.jpg");
        payload.set("product", product);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL))
                .header("Content-Type", "application/json")
                .header("X-API-Key", API_KEY)
                .POST(HttpRequest.BodyPublishers.ofString(mapper.writeValueAsString(payload)))
                .build();

        HttpResponse<String> response = client.send(request,
                HttpResponse.BodyHandlers.ofString());

        if (response.statusCode() == 200) {
            System.out.println("Success: " + response.body());
        } else {
            System.err.println("Error: " + response.body());
        }
    }
}

#!/bin/bash

# Configuration
API_URL="https://thegendai.com/api/v1/generate-description"
API_KEY="your_api_key_here"

# JSON payload
PAYLOAD='{
  "brand_description": "हम प्रीमियम पर्यावरण-अनुकूल उत्पाद बनाते हैं जो स्थिरता को शैली के साथ जोड़ते हैं",
  "audience": "पर्यावरण-सचेत उपभोक्ता जो गुणवत्ता और स्थिरता को महत्व देते हैं",
  "tone_voice": "पेशेवर लेकिन सुलभ, गुणवत्ता और पर्यावरणीय लाभों पर जोर देते हुए",
  "languages": ["english", "spanish"],
  "product": {
    "name": "बांस की पानी की बोतल",
    "category": "पर्यावरण-अनुकूल",
    "price": "24.99",
    "image_url": "https://example.com/product-image.jpg"
  }
}'

# Make the API request
response=$(curl -s -w "HTTPSTATUS:%{http_code}" \
  -X POST "$API_URL" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $API_KEY" \
  -d "$PAYLOAD")

# Extract HTTP status code and body
http_code=$(echo "$response" | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
body=$(echo "$response" | sed -e 's/HTTPSTATUS\:.*//g')

# Check response
if [ "$http_code" -eq 200 ]; then
    echo "Success:"
    echo "$body" | jq '.'
else
    echo "Error (HTTP $http_code):"
    echo "$body"
fi

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

class TheGendaiAPIClient
  API_URL = "https://thegendai.com/api/v1/generate-description"

  def initialize(api_key)
    @api_key = api_key
  end

  def generate_description(brand_description:, audience:, tone_voice:, languages:, product:)
    uri = URI(API_URL)
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true if uri.scheme == 'https'

    request = Net::HTTP::Post.new(uri)
    request['Content-Type'] = 'application/json'
    request['X-API-Key'] = @api_key

    payload = {
      brand_description: brand_description,
      audience: audience,
      tone_voice: tone_voice,
      languages: languages,
      product: product
    }

    request.body = payload.to_json

    response = http.request(request)

    case response.code.to_i
    when 200
      JSON.parse(response.body)
    else
      raise "API Error (#{response.code}): #{response.body}"
    end
  end
end

# Usage example
client = TheGendaiAPIClient.new('your_api_key_here')

begin
  result = client.generate_description(
    brand_description: 'हम प्रीमियम पर्यावरण-अनुकूल उत्पाद बनाते हैं जो स्थिरता को शैली के साथ जोड़ते हैं',
    audience: 'पर्यावरण-सचेत उपभोक्ता जो गुणवत्ता और स्थिरता को महत्व देते हैं',
    tone_voice: 'पेशेवर लेकिन सुलभ, गुणवत्ता और पर्यावरणीय लाभों पर जोर देते हुए',
    languages: ['english', 'spanish'],
    product: {
      name: 'बांस की पानी की बोतल',
      category: 'पर्यावरण-अनुकूल',
      price: '24.99',
      image_url: 'https://example.com/product-image.jpg'
    }
  )

  puts "Success: #{result}"
rescue => e
  puts "Error: #{e.message}"
end

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

public class TheGendaiApiClient
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private const string ApiUrl = "https://thegendai.com/api/v1/generate-description";

    public TheGendaiApiClient(string apiKey)
    {
        _apiKey = apiKey;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Add("X-API-Key", _apiKey);
    }

    public async Task<string> GenerateDescriptionAsync()
    {
        var payload = new
        {
            brand_description = "हम प्रीमियम पर्यावरण-अनुकूल उत्पाद बनाते हैं जो स्थिरता को शैली के साथ जोड़ते हैं",
            audience = "पर्यावरण-सचेत उपभोक्ता जो गुणवत्ता और स्थिरता को महत्व देते हैं",
            tone_voice = "पेशेवर लेकिन सुलभ, गुणवत्ता और पर्यावरणीय लाभों पर जोर देते हुए",
            languages = new[] { "english", "spanish" },
            product = new
            {
                name = "बांस की पानी की बोतल",
                category = "पर्यावरण-अनुकूल",
                price = "24.99",
                image_url = "https://example.com/product-image.jpg"
            }
        };

        var jsonContent = JsonSerializer.Serialize(payload);
        var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");

        try
        {
            var response = await _httpClient.PostAsync(ApiUrl, content);

            if (response.IsSuccessStatusCode)
            {
                return await response.Content.ReadAsStringAsync();
            }
            else
            {
                var errorContent = await response.Content.ReadAsStringAsync();
                throw new Exception($"API Error ({response.StatusCode}): {errorContent}");
            }
        }
        catch (HttpRequestException ex)
        {
            throw new Exception($"Request failed: {ex.Message}");
        }
    }

    public void Dispose()
    {
        _httpClient?.Dispose();
    }
}

// Usage example
class Program
{
    static async Task Main(string[] args)
    {
        var client = new TheGendaiApiClient("your_api_key_here");

        try
        {
            string result = await client.GenerateDescriptionAsync();
            Console.WriteLine($"Success: {result}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
        finally
        {
            client.Dispose();
        }
    }
}

package main

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

type Product struct {
    Name     string `json:"name"`
    Category string `json:"category"`
    Price    string `json:"price"`
    ImageURL string `json:"image_url"`
}

type APIRequest struct {
    BrandDescription     string   `json:"brand_description"`
    Audience            string   `json:"audience"`
    ToneVoice           string   `json:"tone_voice"`
    Languages           []string `json:"languages"`
    Product             Product  `json:"product"`
}

type APIResponse struct {
    Success bool        `json:"success"`
    Data    interface{} `json:"data"`
    Error   string      `json:"error,omitempty"`
}

func generateDescription(apiKey string) (*APIResponse, error) {
    const apiURL = "https://thegendai.com/api/v1/generate-description"

    // Create request payload
    reqData := APIRequest{
        BrandDescription: "हम प्रीमियम पर्यावरण-अनुकूल उत्पाद बनाते हैं जो स्थिरता को शैली के साथ जोड़ते हैं",
        Audience:        "पर्यावरण-सचेत उपभोक्ता जो गुणवत्ता और स्थिरता को महत्व देते हैं",
        ToneVoice:       "पेशेवर लेकिन सुलभ, गुणवत्ता और पर्यावरणीय लाभों पर जोर देते हुए",
        Languages:       []string{"english", "spanish"},
        Product: Product{
            Name:     "बांस की पानी की बोतल",
            Category: "पर्यावरण-अनुकूल",
            Price:    "24.99",
            ImageURL: "https://example.com/product-image.jpg",
        },
    }

    // Marshal to JSON
    jsonData, err := json.Marshal(reqData)
    if err != nil {
        return nil, fmt.Errorf("failed to marshal request: %w", err)
    }

    // Create HTTP request
    req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, fmt.Errorf("failed to create request: %w", err)
    }

    // Set headers
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-Key", apiKey)

    // Make request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("failed to make request: %w", err)
    }
    defer resp.Body.Close()

    // Read response
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("failed to read response: %w", err)
    }

    // Parse response
    var apiResp APIResponse
    if err := json.Unmarshal(body, &apiResp); err != nil {
        return nil, fmt.Errorf("failed to parse response: %w", err)
    }

    if resp.StatusCode != 200 {
        return nil, fmt.Errorf("API error (%d): %s", resp.StatusCode, apiResp.Error)
    }

    return &apiResp, nil
}

func main() {
    apiKey := "your_api_key_here"

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

    fmt.Printf("Success: %+v\n", result)
}

N8N वर्कफ़्लो एकीकरण

यह N8N वर्कफ़्लो दिखाता है कि The Gendai API को आपके स्वचालन वर्कफ़्लो में कैसे एकीकृत करें।

@__raw_block_0__{{ url('/') }}/api/v1/generate-description",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "Content-Type",
              "value": "application/json"
            },
            {
              "name": "X-API-Key",
              "value": "YOUR_API_KEY_HERE"
            }
          ]
        },
        "sendBody": true,
        "jsonBody": "={{ $json.api_payload }}",
        "options": {}
      },
      "id": "api-call",
      "name": "Generate Descriptions",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [900, 300]
    }
  ],
  "connections": {
    "Manual Trigger": {
      "main": [
        [
          {
            "node": "Set Brand Info",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Set Brand Info": {
      "main": [
        [
          {
            "node": "Prepare API Call",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Prepare API Call": {
      "main": [
        [
          {
            "node": "Generate Descriptions",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "pinData": {}
}