{
  "client_id": "9a1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5d",
  "client_secret": "abcdef1234567890abcdef1234567890abcdef12",
  "app_name": "My Awesome App",
  "redirect_uri": "https://www.myawesomeapp.com/auth/callback",
  "auth_url": "https://trimlink.ai/app/authorize?grant_type=authorization_code&client_id=9a1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5d&redirect_uri=https://www.myawesomeapp.com/auth/callback&response_type=code&scope=*"
}

https://trimlink.ai/app/authorize?grant_type=authorization_code&client_id={CLIENT_ID}&redirect_uri={REDIRECT_URI}&response_type=code&scope=*

<a
  href="https://trimlink.ai/app/authorize?grant_type=authorization_code&client_id=YOUR_CLIENT_ID&redirect_uri=YOUR_REDIRECT_URI&response_type=code&scope=*"
  class="btn btn-primary">
  Connect with Trimlink
</a>

https://www.myawesomeapp.com/auth/callback?code=def50200...&state=xyz123

https://www.myawesomeapp.com/auth/callback?error=access_denied&error_description=The+user+denied+the+request

{
  "grant_type": "authorization_code",
  "client_id": "YOUR_CLIENT_ID",
  "client_secret": "YOUR_CLIENT_SECRET",
  "redirect_uri": "YOUR_REDIRECT_URI",
  "code": "AUTHORIZATION_CODE_FROM_CALLBACK"
}

{
  "token_type": "Bearer",
  "expires_in": 31536000,
  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9...",
  "refresh_token": "def502001234567890abcdef..."
}

Authorization: Bearer YOUR_ACCESS_TOKEN

curl -X GET "https://trimlink.ai/api/1.0/short-urls/list-all-short-urls" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Accept: application/json"

<?php

class TrimLinkOAuthClient
{
    private $clientId;
    private $clientSecret;
    private $redirectUri;

    public function __construct($clientId, $clientSecret, $redirectUri)
    {
        $this->clientId = $clientId;
        $this->clientSecret = $clientSecret;
        $this->redirectUri = $redirectUri;
    }

    /**
     * Generate authorization URL
     */
    public function getAuthorizationUrl($state = null)
    {
        $params = [
            'grant_type' => 'authorization_code',
            'client_id' => $this->clientId,
            'redirect_uri' => $this->redirectUri,
            'response_type' => 'code',
            'scope' => '*'
        ];

        if ($state) {
            $params['state'] = $state;
        }

        return 'https://trimlink.ai/app/authorize?' . http_build_query($params);
    }

    /**
     * Exchange authorization code for access token
     */
    public function getAccessToken($authorizationCode)
    {
        $data = http_build_query([
            'grant_type' => 'authorization_code',
            'client_id' => $this->clientId,
            'client_secret' => $this->clientSecret,
            'redirect_uri' => $this->redirectUri,
            'code' => $authorizationCode
       ]);

       $ch = curl_init('https://trimlink.ai/api/oauth/token');
       curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_POST => true,
            CURLOPT_POSTFIELDS => $data,
            CURLOPT_HTTPHEADER => [
                'Content-Type: application/x-www-form-urlencoded',
            ],
        ]);

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

        if ($httpCode !== 200) {
            dd('Token exchange failed:', $response);
        }
        return json_decode($response, true);
    }

    /**
     * Make authenticated API request
     */
    public function makeApiRequest($endpoint, $method = 'GET', $data = null, $accessToken)
    {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, 'https://trimlink.ai' . $endpoint);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Authorization: Bearer ' . $accessToken,
            'Accept: application/json',
            'Content-Type: application/json'
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        if ($data && in_array($method, ['POST', 'PUT', 'PATCH'])) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }

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

        return [
            'status_code' => $httpCode,
            'body' => json_decode($response, true)
        ];
    }
}

// Usage Example
$oauth = new TrimLinkOAuthClient(
    'YOUR_CLIENT_ID',
    'YOUR_CLIENT_SECRET',
    'https://yourapp.com/auth/callback'
);

// Step 1: Redirect user to authorization URL
if (!isset($_GET['code'])) {
    $authUrl = $oauth->getAuthorizationUrl($_SESSION['oauth_state']);
    header('Location: ' . $authUrl);
    exit;
}

// Step 2: Handle callback and exchange code for token
try {
    $tokenData = $oauth->getAccessToken($_GET['code']);
    $accessToken = $tokenData['access_token'];

    // Store access token securely (database, session, etc.)
    $_SESSION['access_token'] = $accessToken;

    // Step 3: Make API requests
    $response = $oauth->makeApiRequest('/api/1.0/short-urls/list-all-short-urls', 'GET', null, $accessToken);

    if ($response['status_code'] === 200) {
        $shortUrls = $response['body'];
        // Process the data
    }

} catch (Exception $e) {
    echo 'OAuth Error: ' . $e->getMessage();
}
?>

import requests
import urllib.parse
from typing import Dict, Optional

class TrimLinkOAuthClient:
    def __init__(self, client_id: str, client_secret: str, redirect_uri: str):
        self.client_id = client_id
        self.client_secret = client_secret
        self.redirect_uri = redirect_uri
        self.base_url = "https://trimlink.ai"

    def get_authorization_url(self, state: Optional[str] = None) -> str:
        """Generate authorization URL"""
        params = {
            'grant_type': 'authorization_code',
            'client_id': self.client_id,
            'redirect_uri': self.redirect_uri,
            'response_type': 'code',
            'scope': '*'
        }

        if state:
            params['state'] = state

        return f"{self.base_url}/app/authorize?{urllib.parse.urlencode(params)}"

    def get_access_token(self, authorization_code: str) -> Dict:
        """Exchange authorization code for access token"""
        data = {
            'grant_type': 'authorization_code',
            'client_id': self.client_id,
            'client_secret': self.client_secret,
            'redirect_uri': self.redirect_uri,
            'code': authorization_code
        }

        response = requests.post(
            f"{self.base_url}/api/oauth/token",
            json=data,
            headers={'Accept': 'application/json'}
        )

        if response.status_code != 200:
            raise Exception(f"Token exchange failed: {response.text}")

        return response.json()

    def make_api_request(self, endpoint: str, method: str = 'GET',
                        data: Optional[Dict] = None, access_token: str = None) -> Dict:
        """Make authenticated API request"""
        headers = {
            'Authorization': f'Bearer {access_token}',
            'Accept': 'application/json',
            'Content-Type': 'application/json'
        }

        url = f"{self.base_url}{endpoint}"

        if method.upper() == 'GET':
            response = requests.get(url, headers=headers)
        elif method.upper() == 'POST':
            response = requests.post(url, json=data, headers=headers)
        elif method.upper() == 'PUT':
            response = requests.put(url, json=data, headers=headers)
        elif method.upper() == 'DELETE':
            response = requests.delete(url, headers=headers)
        else:
            raise ValueError(f"Unsupported HTTP method: {method}")

        return {
            'status_code': response.status_code,
            'body': response.json() if response.content else None
        }

# Usage Example (Flask)
from flask import Flask, request, redirect, session

app = Flask(__name__)
app.secret_key = 'your-secret-key'

oauth = TrimLinkOAuthClient(
    client_id='YOUR_CLIENT_ID',
    client_secret='YOUR_CLIENT_SECRET',
    redirect_uri='https://yourapp.com/auth/callback'
)

@app.route('/auth/login')
def login():
    """Redirect to OAuth authorization"""
    auth_url = oauth.get_authorization_url()
    return redirect(auth_url)

@app.route('/auth/callback')
def callback():
    """Handle OAuth callback"""
    code = request.args.get('code')
    error = request.args.get('error')

    if error:
        return f"Authorization failed: {error}"

    try:
        # Exchange code for token
        token_data = oauth.get_access_token(code)
        session['access_token'] = token_data['access_token']

        # Make API request
        response = oauth.make_api_request(
            '/api/1.0/short-urls/list-all-short-urls',
            'GET',
            access_token=session['access_token']
        )

        if response['status_code'] == 200:
            return f"Success! Retrieved {len(response['body']['data'])} URLs"
        else:
            return f"API request failed: {response['body']}"

    except Exception as e:
        return f"OAuth error: {str(e)}"

if __name__ == '__main__':
    app.run(debug=True)

const axios = require("axios");
const express = require("express");
const session = require("express-session");

class TrimLinkOAuthClient {
  constructor(clientId, clientSecret, redirectUri) {
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.redirectUri = redirectUri;
    this.baseUrl = "https://trimlink.ai";
  }

  /**
   * Generate authorization URL
   */
  getAuthorizationUrl(state = null) {
    const params = new URLSearchParams({
      grant_type: "authorization_code",
      client_id: this.clientId,
      redirect_uri: this.redirectUri,
      response_type: "code",
      scope: "*",
    });

    if (state) {
      params.append("state", state);
    }

    return `${this.baseUrl}/app/authorize?${params.toString()}`;
  }

  /**
   * Exchange authorization code for access token
   */
  async getAccessToken(authorizationCode) {
    const data = {
      grant_type: "authorization_code",
      client_id: this.clientId,
      client_secret: this.clientSecret,
      redirect_uri: this.redirectUri,
      code: authorizationCode,
    };

    try {
      const response = await axios.post(
        `${this.baseUrl}/api/oauth/token`,
        data,
        {
          headers: {
            Accept: "application/json",
            "Content-Type": "application/json",
          },
        },
      );

      return response.data;
    } catch (error) {
      throw new Error(
        `Token exchange failed: ${error.response?.data || error.message}`,
      );
    }
  }

  /**
   * Make authenticated API request
   */
  async makeApiRequest(endpoint, method = "GET", data = null, accessToken) {
    const config = {
      method: method.toLowerCase(),
      url: `${this.baseUrl}${endpoint}`,
      headers: {
        Authorization: `Bearer ${accessToken}`,
        Accept: "application/json",
        "Content-Type": "application/json",
      },
    };

    if (data && ["post", "put", "patch"].includes(method.toLowerCase())) {
      config.data = data;
    }

    try {
      const response = await axios(config);
      return {
        statusCode: response.status,
        body: response.data,
      };
    } catch (error) {
      return {
        statusCode: error.response?.status || 500,
        body: error.response?.data || { message: error.message },
      };
    }
  }
}

// Usage Example (Express.js)
const app = express();

app.use(
  session({
    secret: "your-secret-key",
    resave: false,
    saveUninitialized: true,
  }),
);

const oauth = new TrimLinkOAuthClient(
  "YOUR_CLIENT_ID",
  "YOUR_CLIENT_SECRET",
  "https://yourapp.com/auth/callback",
);

// Route to initiate OAuth
app.get("/auth/login", (req, res) => {
  const authUrl = oauth.getAuthorizationUrl();
  res.redirect(authUrl);
});

// OAuth callback route
app.get("/auth/callback", async (req, res) => {
  const { code, error } = req.query;

  if (error) {
    return res.status(400).send(`Authorization failed: ${error}`);
  }

  try {
    // Exchange code for token
    const tokenData = await oauth.getAccessToken(code);
    req.session.accessToken = tokenData.access_token;

    // Make API request
    const response = await oauth.makeApiRequest(
      "/api/1.0/short-urls/list-all-short-urls",
      "GET",
      null,
      req.session.accessToken,
    );

    if (response.statusCode === 200) {
      res.json({
        message: "Success!",
        data: response.body,
      });
    } else {
      res.status(response.statusCode).json(response.body);
    }
  } catch (error) {
    res.status(500).send(`OAuth error: ${error.message}`);
  }
});

// Protected API route example
app.get("/api/urls", async (req, res) => {
  if (!req.session.accessToken) {
    return res.status(401).json({ error: "Not authenticated" });
  }

  try {
    const response = await oauth.makeApiRequest(
      "/api/1.0/short-urls/list-all-short-urls",
      "GET",
      null,
      req.session.accessToken,
    );

    res.status(response.statusCode).json(response.body);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.listen(3000, () => {
  console.log("Server running on http://localhost:3000");
});