Authentifizierung

curl -X POST https://apphighway.com/api/v1/structify \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "John Doe is 35 years old and lives in New York",
    "schema": {
      "name": "string",
      "age": "number",
      "city": "string"
    }
  }'

import fetch from 'node-fetch';

const API_TOKEN = 'your_api_token_here';
const API_URL = 'https://apphighway.com/api/v1';

async function callAPI(endpoint, data) {
  const response = await fetch(`${API_URL}/${endpoint}`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(data),
  });

  if (!response.ok) {
    throw new Error(`API call failed: ${response.statusText}`);
  }

  return response.json();
}

// Example: Use Structify API
const result = await callAPI('structify', {
  text: 'John Doe is 35 years old',
  schema: { name: 'string', age: 'number' }
});

console.log(result);

import requests

API_TOKEN = 'your_api_token_here'
API_URL = 'https://apphighway.com/api/v1'

def call_api(endpoint, data):
    headers = {
        'Authorization': f'Bearer {API_TOKEN}',
        'Content-Type': 'application/json'
    }

    response = requests.post(
        f'{API_URL}/{endpoint}',
        headers=headers,
        json=data
    )

    response.raise_for_status()
    return response.json()

# Example: Use Structify API
result = call_api('structify', {
    'text': 'John Doe is 35 years old',
    'schema': {'name': 'string', 'age': 'number'}
})

print(result)

const API_TOKEN = process.env.APPHIGHWAY_API_TOKEN!;
const API_URL = 'https://apphighway.com/api/v1';

interface APIError {
  error: {
    code: string;
    message: string;
    details: string;
  };
}

interface APIResponse<T> {
  status: string;
  data: T;
  pointsUsed: number;
  remainingPoints: number;
}

async function callAPI<T>(
  endpoint: string,
  data: Record<string, unknown>
): Promise<APIResponse<T>> {
  const response = await fetch(`${API_URL}/${endpoint}`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(data),
  });

  const result = await response.json();

  if (!response.ok) {
    const apiError = result as APIError;

    if (apiError?.error?.code === 'INSUFFICIENT_POINTS') {
      throw new Error('Insufficient points. Please purchase more points.');
    }

    if (apiError?.error?.code === 'UNAUTHORIZED') {
      throw new Error('Invalid API token. Please check your credentials.');
    }

    if (response.status === 429) {
      throw new Error('Rate limit exceeded. Please wait before retrying.');
    }

    throw new Error(apiError?.error?.message || 'API request failed');
  }

  return result as APIResponse<T>;
}

// Usage
const result = await callAPI('structify', {
  text: 'John Doe is 35 years old',
  schema: { name: 'string', age: 'number' }
});

console.log(result.data);
console.log(`Points used: ${result.pointsUsed}`);

import fetch from 'node-fetch';

const API_TOKEN = process.env.APPHIGHWAY_API_TOKEN;
const API_URL = 'https://apphighway.com/api/v1';

async function callAPIWithRetry(
  endpoint: string,
  data: object,
  maxRetries = 3
) {
  let lastError;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(`${API_URL}/${endpoint}`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${API_TOKEN}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(data),
      });

      // Don't retry on client errors (4xx except 429)
      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
        const error = await response.json();
        throw new Error(`API Error: ${error.error.message}`);
      }

      // Retry on server errors (5xx) or rate limits (429)
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }

      return await response.json();
    } catch (error) {
      lastError = error;

      if (attempt < maxRetries - 1) {
        // Exponential backoff: 1s, 2s, 4s
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Retry attempt ${attempt + 1} after ${delay}ms`);
        await new Promise(resolve => setTimeout(resolve, delay));
      }
    }
  }

  throw lastError;
}

// Usage
const result = await callAPIWithRetry('structify', {
  text: 'John Doe is 35 years old',
  schema: { name: 'string', age: 'number' }
});

package main

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

const apiURL = "https://apphighway.com/api/v1"

type APIClient struct {
    Token      string
    HTTPClient *http.Client
}

type APIError struct {
    Error struct {
        Code    string `json:"code"`
        Message string `json:"message"`
        Details string `json:"details"`
    } `json:"error"`
}

func NewClient(token string) *APIClient {
    return &APIClient{
        Token:      token,
        HTTPClient: &http.Client{},
    }
}

func (c *APIClient) Call(endpoint string, data interface{}) ([]byte, error) {
    jsonData, err := json.Marshal(data)
    if err != nil {
        return nil, fmt.Errorf("failed to marshal data: %w", err)
    }

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

    req.Header.Set("Authorization", "Bearer "+c.Token)
    req.Header.Set("Content-Type", "application/json")

    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, fmt.Errorf("request failed: %w", err)
    }
    defer resp.Body.Close()

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

    if resp.StatusCode != http.StatusOK {
        var apiErr APIError
        if err := json.Unmarshal(body, &apiErr); err == nil {
            return nil, fmt.Errorf("API error: %s", apiErr.Error.Message)
        }
        return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
    }

    return body, nil
}

func main() {
    client := NewClient(os.Getenv("APPHIGHWAY_API_TOKEN"))

    data := map[string]interface{}{
        "text": "John Doe is 35 years old",
        "schema": map[string]string{
            "name": "string",
            "age":  "number",
        },
    }

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

    fmt.Printf("Result: %s\n", result)
}

{
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Invalid or expired API token",
    "details": "The provided token is not valid or has expired"
  }
}

{
  "error": {
    "code": "INSUFFICIENT_POINTS",
    "message": "Insufficient points. Required: 3, Available: 1",
    "details": "Please purchase more points to continue using the API"
  }
}