Code Examples

This page provides copy-paste examples in popular languages for calling your Endprompt endpoints.

JavaScript / Node.js

Using Fetch

async function callEndprompt(text) {
  const response = await fetch('https://acme.api.endprompt.ai/api/v1/summarize', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': process.env.ENDPROMPT_API_KEY
    },
    body: JSON.stringify({
      text: text,
      max_length: 100
    })
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.message);
  }

  return await response.json();
}

// Usage
const result = await callEndprompt('Your long text here...');
console.log(result.summary);

Using Axios

const axios = require('axios');

async function callEndprompt(text) {
  try {
    const response = await axios.post(
      'https://acme.api.endprompt.ai/api/v1/summarize',
      {
        text: text,
        max_length: 100
      },
      {
        headers: {
          'Content-Type': 'application/json',
          'x-api-key': process.env.ENDPROMPT_API_KEY
        },
        timeout: 60000 // 60 second timeout
      }
    );

    return response.data;
  } catch (error) {
    if (error.response) {
      throw new Error(error.response.data.message);
    }
    throw error;
  }
}

Python

Using Requests

import os
import requests

def call_endprompt(text: str) -> dict:
    response = requests.post(
        'https://acme.api.endprompt.ai/api/v1/summarize',
        headers={
            'Content-Type': 'application/json',
            'x-api-key': os.environ.get('ENDPROMPT_API_KEY')
        },
        json={
            'text': text,
            'max_length': 100
        },
        timeout=60
    )
    
    response.raise_for_status()
    return response.json()

# Usage
result = call_endprompt('Your long text here...')
print(result['summary'])

Using HTTPX (Async)

import os
import httpx

async def call_endprompt(text: str) -> dict:
    async with httpx.AsyncClient() as client:
        response = await client.post(
            'https://acme.api.endprompt.ai/api/v1/summarize',
            headers={
                'Content-Type': 'application/json',
                'x-api-key': os.environ.get('ENDPROMPT_API_KEY')
            },
            json={
                'text': text,
                'max_length': 100
            },
            timeout=60.0
        )
        
        response.raise_for_status()
        return response.json()

# Usage
import asyncio
result = asyncio.run(call_endprompt('Your long text here...'))

TypeScript

interface SummarizeRequest {
  text: string;
  max_length?: number;
}

interface SummarizeResponse {
  summary: string;
  word_count: number;
}

async function callEndprompt(request: SummarizeRequest): Promise<SummarizeResponse> {
  const response = await fetch('https://acme.api.endprompt.ai/api/v1/summarize', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': process.env.ENDPROMPT_API_KEY!
    },
    body: JSON.stringify(request)
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.message);
  }

  return await response.json() as SummarizeResponse;
}

// Usage
const result = await callEndprompt({ text: 'Your long text...', max_length: 100 });
console.log(result.summary);

C# / .NET

using System.Net.Http;
using System.Net.Http.Json;

public class EndpromptClient
{
    private readonly HttpClient _httpClient;
    
    public EndpromptClient(string apiKey)
    {
        _httpClient = new HttpClient
        {
            BaseAddress = new Uri("https://acme.api.endprompt.ai"),
            Timeout = TimeSpan.FromSeconds(60)
        };
        _httpClient.DefaultRequestHeaders.Add("x-api-key", apiKey);
    }
    
    public async Task<SummarizeResponse> SummarizeAsync(string text, int maxLength = 100)
    {
        var request = new { text, max_length = maxLength };
        
        var response = await _httpClient.PostAsJsonAsync("/api/v1/summarize", request);
        response.EnsureSuccessStatusCode();
        
        return await response.Content.ReadFromJsonAsync<SummarizeResponse>();
    }
}

public record SummarizeResponse(string Summary, int WordCount);

// Usage
var client = new EndpromptClient(Environment.GetEnvironmentVariable("ENDPROMPT_API_KEY"));
var result = await client.SummarizeAsync("Your long text here...");
Console.WriteLine(result.Summary);

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    "time"
)

type SummarizeRequest struct {
    Text      string `json:"text"`
    MaxLength int    `json:"max_length,omitempty"`
}

type SummarizeResponse struct {
    Summary   string `json:"summary"`
    WordCount int    `json:"word_count"`
}

func CallEndprompt(text string, maxLength int) (*SummarizeResponse, error) {
    client := &http.Client{Timeout: 60 * time.Second}
    
    reqBody, _ := json.Marshal(SummarizeRequest{
        Text:      text,
        MaxLength: maxLength,
    })
    
    req, _ := http.NewRequest("POST", 
        "https://acme.api.endprompt.ai/api/v1/summarize",
        bytes.NewBuffer(reqBody))
    
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("x-api-key", os.Getenv("ENDPROMPT_API_KEY"))
    
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var result SummarizeResponse
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, err
    }
    
    return &result, nil
}

Ruby

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

def call_endprompt(text, max_length: 100)
  uri = URI('https://acme.api.endprompt.ai/api/v1/summarize')
  
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  http.read_timeout = 60
  
  request = Net::HTTP::Post.new(uri.path)
  request['Content-Type'] = 'application/json'
  request['x-api-key'] = ENV['ENDPROMPT_API_KEY']
  request.body = { text: text, max_length: max_length }.to_json
  
  response = http.request(request)
  
  raise "Error: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
  
  JSON.parse(response.body)
end

# Usage
result = call_endprompt('Your long text here...')
puts result['summary']

PHP

<?php

function callEndprompt(string $text, int $maxLength = 100): array {
    $url = 'https://acme.api.endprompt.ai/api/v1/summarize';
    
    $data = [
        'text' => $text,
        'max_length' => $maxLength
    ];
    
    $options = [
        'http' => [
            'method' => 'POST',
            'header' => implode("\r\n", [
                'Content-Type: application/json',
                'x-api-key: ' . getenv('ENDPROMPT_API_KEY')
            ]),
            'content' => json_encode($data),
            'timeout' => 60
        ]
    ];
    
    $context = stream_context_create($options);
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Request failed');
    }
    
    return json_decode($response, true);
}

// Usage
$result = callEndprompt('Your long text here...');
echo $result['summary'];

Error Handling Pattern

All examples should include proper error handling:

try {
  const result = await callEndprompt(text);
  return result;
} catch (error) {
  if (error.status === 401) {
    console.error('Invalid API key');
  } else if (error.status === 422) {
    console.error('Validation error:', error.message);
  } else if (error.status === 429) {
    console.error('Rate limited, retry after:', error.retryAfter);
  } else {
    console.error('Unexpected error:', error.message);
  }
  throw error;
}

Image Generation

Generate images by calling an endpoint configured with an image output field and an image generation model.

const response = await fetch('https://acme.api.endprompt.ai/api/v1/generate-product-image', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': process.env.ENDPROMPT_API_KEY
  },
  body: JSON.stringify({
    description: 'A minimalist product photo of a ceramic coffee mug on a marble surface'
  })
});

const data = await response.json();

// Save each generated image
for (const image of data.generatedImages) {
  const buffer = Buffer.from(image.base64Data, 'base64');
  fs.writeFileSync('output.png', buffer);
  console.log('Revised prompt:', image.revisedPrompt);
}

import os
import base64
import requests

response = requests.post(
    'https://acme.api.endprompt.ai/api/v1/generate-product-image',
    headers={
        'Content-Type': 'application/json',
        'x-api-key': os.environ.get('ENDPROMPT_API_KEY')
    },
    json={
        'description': 'A minimalist product photo of a ceramic coffee mug on a marble surface'
    }
)

data = response.json()

for i, image in enumerate(data['generatedImages']):
    img_bytes = base64.b64decode(image['base64Data'])
    with open(f'output_{i}.png', 'wb') as f:
        f.write(img_bytes)
    print('Revised prompt:', image.get('revisedPrompt'))

Vision / Image Analysis

Send images to a vision-capable endpoint for analysis.

import fs from 'fs';

// Read and base64-encode the image
const imageBuffer = fs.readFileSync('product-photo.jpg');
const base64Image = `data:image/jpeg;base64,${imageBuffer.toString('base64')}`;

const response = await fetch('https://acme.api.endprompt.ai/api/v1/analyze-image', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': process.env.ENDPROMPT_API_KEY
  },
  body: JSON.stringify({
    photo: base64Image,
    analysis_type: 'product-description'
  })
});

const result = await response.json();
console.log(result);
// { "description": "A ceramic coffee mug...", "tags": ["ceramic", "mug", "kitchen"], ... }

import os
import base64
import requests

# Read and base64-encode the image
with open('product-photo.jpg', 'rb') as f:
    image_data = base64.b64encode(f.read()).decode('utf-8')

base64_image = f'data:image/jpeg;base64,{image_data}'

response = requests.post(
    'https://acme.api.endprompt.ai/api/v1/analyze-image',
    headers={
        'Content-Type': 'application/json',
        'x-api-key': os.environ.get('ENDPROMPT_API_KEY')
    },
    json={
        'photo': base64_image,
        'analysis_type': 'product-description'
    }
)

result = response.json()
print(result)
# {"description": "A ceramic coffee mug...", "tags": ["ceramic", "mug", "kitchen"], ...}

API Basics

JavaScript / Node.js

Using Fetch

Using Axios

Python

Using Requests

Using HTTPX (Async)

TypeScript

C# / .NET

Go

Ruby

PHP

Error Handling Pattern

Image Generation

Vision / Image Analysis

Next Steps

Error Handling

Logs & Monitoring

​JavaScript / Node.js

​Using Fetch

​Using Axios

​Python

​Using Requests

​Using HTTPX (Async)

​TypeScript

​C# / .NET

​Go

​Ruby

​PHP

​Error Handling Pattern

​Image Generation

​Vision / Image Analysis

​Next Steps

Error Handling

Logs & Monitoring

JavaScript / Node.js

Using Fetch

Using Axios

Python

Using Requests

Using HTTPX (Async)

TypeScript

C# / .NET

Go

Ruby

PHP

Error Handling Pattern

Image Generation

Vision / Image Analysis

Next Steps