Tapback Documentation

<template>
  <div 
    :data-tapback-widget="siteId" 
    :data-source="source"
    :class="className"
  ></div>
</template>

<script>
export default {
  name: 'FeedbackWidget',
  props: {
    siteId: {
      type: String,
      required: true
    },
    source: {
      type: String,
      default: 'default'
    },
    className: {
      type: String,
      default: ''
    }
  },
  mounted() {
    const script = document.createElement('script');
    script.src = 'https://tapback.dev/widget.js';
    script.async = true;
    document.body.appendChild(script);
  },
  beforeUnmount() {
    const existingScript = document.querySelector('script[src="https://tapback.dev/widget.js"]');
    if (existingScript) {
      document.body.removeChild(existingScript);
    }
  }
}
</script>

<script>
  import { onMount, onDestroy } from 'svelte';
  
  export let siteId;
  export let source = 'default';
  export let className = '';
  
  onMount(() => {
    const script = document.createElement('script');
    script.src = 'https://tapback.dev/widget.js';
    script.async = true;
    document.body.appendChild(script);
  });
  
  onDestroy(() => {
    const existingScript = document.querySelector('script[src="https://tapback.dev/widget.js"]');
    if (existingScript) {
      document.body.removeChild(existingScript);
    }
  });
</script>

<div 
  data-tapback-widget={siteId} 
  data-source={source}
  class={className}
></div>

const axios = require('axios');

class TapbackClient {
  constructor(apiKey, baseURL = 'https://tapback.dev/api/v1') {
    this.client = axios.create({
      baseURL,
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      }
    });
  }

  // Sites
  async createSite(name, domain) {
    const response = await this.client.post('/sites', { name, domain });
    return response.data;
  }

  async getSites() {
    const response = await this.client.get('/sites');
    return response.data;
  }

  async getSite(siteId) {
    const response = await this.client.get(`/sites/${siteId}`);
    return response.data;
  }

  async updateSite(siteId, data) {
    const response = await this.client.put(`/sites/${siteId}`, data);
    return response.data;
  }

  async deleteSite(siteId) {
    const response = await this.client.delete(`/sites/${siteId}`);
    return response.data;
  }

  // Analytics
  async getSiteAnalytics(siteId) {
    const response = await this.client.get(`/sites/${siteId}/analytics`);
    return response.data;
  }

  // Tokens
  async createToken(name, expiresAt) {
    const response = await this.client.post('/tokens', { name, expires_at: expiresAt });
    return response.data;
  }

  async getTokens() {
    const response = await this.client.get('/tokens');
    return response.data;
  }

  async deleteToken(tokenId) {
    const response = await this.client.delete(`/tokens/${tokenId}`);
    return response.data;
  }
}

module.exports = TapbackClient;

const TapbackClient = require('./tapback-client');

async function main() {
  const client = new TapbackClient('your-api-key');
  
  try {
    // Create a new site
    const site = await client.createSite('My Website', 'example.com');
    console.log('Created site:', site);
    
    // Get analytics
    const analytics = await client.getSiteAnalytics(site.uuid);
    console.log('Analytics:', analytics);
    
  } catch (error) {
    console.error('Error:', error.response?.data || error.message);
  }
}

main();

import requests
from typing import Optional, Dict, Any

class TapbackClient:
    def __init__(self, api_key: str, base_url: str = 'https://tapback.dev/api/v1'):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
    
    def _request(self, method: str, endpoint: str, data: Optional[Dict] = None) -> Dict[str, Any]:
        url = f'{self.base_url}{endpoint}'
        response = requests.request(method, url, headers=self.headers, json=data)
        response.raise_for_status()
        return response.json()
    
    # Sites
    def create_site(self, name: str, domain: Optional[str] = None) -> Dict[str, Any]:
        return self._request('POST', '/sites', {'name': name, 'domain': domain})
    
    def get_sites(self) -> Dict[str, Any]:
        return self._request('GET', '/sites')
    
    def get_site(self, site_id: str) -> Dict[str, Any]:
        return self._request('GET', f'/sites/{site_id}')
    
    def update_site(self, site_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
        return self._request('PUT', f'/sites/{site_id}', data)
    
    def delete_site(self, site_id: str) -> None:
        self._request('DELETE', f'/sites/{site_id}')
    
    # Analytics
    def get_site_analytics(self, site_id: str) -> Dict[str, Any]:
        return self._request('GET', f'/sites/{site_id}/analytics')
    
    # Tokens
    def create_token(self, name: str, expires_at: Optional[str] = None) -> Dict[str, Any]:
        return self._request('POST', '/tokens', {'name': name, 'expires_at': expires_at})
    
    def get_tokens(self) -> Dict[str, Any]:
        return self._request('GET', '/tokens')
    
    def delete_token(self, token_id: str) -> None:
        self._request('DELETE', f'/tokens/{token_id}')

<?php

class TapbackClient
{
    private string $apiKey;
    private string $baseUrl;
    
    public function __construct(string $apiKey, string $baseUrl = 'https://tapback.dev/api/v1')
    {
        $this->apiKey = $apiKey;
        $this->baseUrl = $baseUrl;
    }
    
    private function request(string $method, string $endpoint, ?array $data = null): array
    {
        $url = $this->baseUrl . $endpoint;
        $headers = [
            'Authorization: Bearer ' . $this->apiKey,
            'Content-Type: application/json'
        ];
        
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
        
        if ($data) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        
        if ($httpCode >= 400) {
            throw new Exception('API request failed: ' . $response);
        }
        
        return json_decode($response, true);
    }
    
    // Sites
    public function createSite(string $name, ?string $domain = null): array
    {
        return $this->request('POST', '/sites', ['name' => $name, 'domain' => $domain]);
    }
    
    public function getSites(): array
    {
        return $this->request('GET', '/sites');
    }
    
    public function getSite(string $siteId): array
    {
        return $this->request('GET', '/sites/' . $siteId);
    }
    
    public function updateSite(string $siteId, array $data): array
    {
        return $this->request('PUT', '/sites/' . $siteId, $data);
    }
    
    public function deleteSite(string $siteId): void
    {
        $this->request('DELETE', '/sites/' . $siteId);
    }
    
    // Analytics
    public function getSiteAnalytics(string $siteId): array
    {
        return $this->request('GET', '/sites/' . $siteId . '/analytics');
    }
    
    // Tokens
    public function createToken(string $name, ?string $expiresAt = null): array
    {
        return $this->request('POST', '/tokens', ['name' => $name, 'expires_at' => $expiresAt]);
    }
    
    public function getTokens(): array
    {
        return $this->request('GET', '/tokens');
    }
    
    public function deleteToken(string $tokenId): void
    {
        $this->request('DELETE', '/tokens/' . $tokenId);
    }
}