Quickstart

const response = await fetch('https://link.emergedata.ai/configs', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${API_TOKEN}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    config_name: 'default',
    company_name: 'Your Company',
    logo_url: 'https://yourcompany.com/logo.png',
    privacy_policy_url: 'https://yourcompany.com/privacy',
    is_default: true
  })
});

import requests

response = requests.post(
    'https://link.emergedata.ai/configs',
    headers={
        'Authorization': f'Bearer {API_TOKEN}',
        'Content-Type': 'application/json'
    },
    json={
        'config_name': 'default',
        'company_name': 'Your Company',
        'logo_url': 'https://yourcompany.com/logo.png',
        'privacy_policy_url': 'https://yourcompany.com/privacy',
        'is_default': True
    }
)

import crypto from 'crypto';

function createLinkUrl(params: {
  clientId: string;
  signingSecret: string;
  redirectUri: string;
  userId: string;
}) {
  const timestamp = new Date().toISOString();
  const state = crypto.randomBytes(16).toString('hex');

  // Build parameters object
  const urlParams: Record<string, string> = {
    client_id: params.clientId,
    redirect_uri: params.redirectUri,
    state: state,
    timestamp: timestamp,
    uid: params.userId
  };

  // Sort parameters alphabetically for signature
  const sortedKeys = Object.keys(urlParams).sort();
  const signatureBase = sortedKeys
    .map(key => `${key}=${urlParams[key]}`)
    .join('&');

  const signature = crypto
    .createHmac('sha256', params.signingSecret)
    .update(signatureBase)
    .digest('hex');

  // Build final URL with URL-encoded parameters
  const finalParams = new URLSearchParams(urlParams);
  finalParams.append('signature', signature);

  return `https://link.emergedata.ai/link/start?${finalParams.toString()}`;
}

// Usage
const linkUrl = createLinkUrl({
  clientId: 'your_client_id',
  signingSecret: 'your_signing_secret',
  redirectUri: 'https://yourcompany.com/callback',
  userId: 'psub_d4e5f6789012345678901234abcdef01'
});

import hmac
import hashlib
from datetime import datetime, timezone
import secrets
from urllib.parse import urlencode

def create_link_url(
    client_id: str,
    signing_secret: str,
    redirect_uri: str,
    user_id: str
) -> str:
    timestamp = datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')
    state = secrets.token_hex(16)

    params = {
        'client_id': client_id,
        'redirect_uri': redirect_uri,
        'state': state,
        'timestamp': timestamp,
        'uid': user_id
    }

    # Sort parameters alphabetically for signature
    sorted_params = sorted(params.items())
    signature_base = '&'.join(f'{k}={v}' for k, v in sorted_params)

    signature = hmac.new(
        signing_secret.encode(),
        signature_base.encode(),
        hashlib.sha256
    ).hexdigest()

    params['signature'] = signature

    return f"https://link.emergedata.ai/link/start?{urlencode(params)}"

# Usage
link_url = create_link_url(
    client_id='your_client_id',
    signing_secret='your_signing_secret',
    redirect_uri='https://yourcompany.com/callback',
    user_id='psub_d4e5f6789012345678901234abcdef01'
)

// Express.js example
app.get('/callback', (req, res) => {
  const { status, state, uid, error_code } = req.query;

  // Verify state matches what you stored
  if (!verifyState(state)) {
    return res.status(400).send('Invalid state');
  }

  if (status === 'success' || status === 'reauthorized') {
    // Consent granted - data export will start automatically
    // Next step: poll /export/status/{uid} and wait for provider-level readiness
    console.log(`User ${uid} granted consent`);
    res.redirect('/success');
  } else {
    console.log(`Consent failed: ${error_code}`);
    res.redirect('/error');
  }
});

# FastAPI example
from fastapi import FastAPI, Request
from fastapi.responses import RedirectResponse

app = FastAPI()

@app.get('/callback')
async def callback(
    status: str,
    state: str,
    uid: str,
    error_code: str = None
):
    # Verify state matches what you stored
    if not verify_state(state):
        return RedirectResponse('/error')

    if status in ('success', 'reauthorized'):
        # Consent granted - data export will start automatically
        print(f'User {uid} granted consent')
        return RedirectResponse('/success')
    else:
        print(f'Consent failed: {error_code}')
        return RedirectResponse('/error')

async function waitForProviderExport(uid: string, provider: 'google_data' | 'gmail') {
  for (let attempt = 1; attempt <= 10; attempt += 1) {
    const response = await fetch(
      `https://link.emergedata.ai/export/status/${encodeURIComponent(uid)}`,
      {
        headers: {
          Authorization: `Bearer ${API_TOKEN}`
        }
      }
    );

    if (!response.ok) {
      const body = await response.text();
      throw new Error(`Export status failed (${response.status}): ${body}`);
    }

    const payload = await response.json() as {
      uid: string;
      sources: Array<{ provider: string; data_ready: boolean }>;
    };

    const source = payload.sources.find((item) => item.provider === provider);
    if (source?.data_ready) {
      return;
    }

    await new Promise((resolve) => setTimeout(resolve, 1500 * attempt));
  }

  throw new Error(`Export not ready for provider ${provider}`);
}

import time
import requests

def wait_for_provider_export(uid: str, provider: str) -> None:
    for attempt in range(1, 11):
        response = requests.get(
            f'https://link.emergedata.ai/export/status/{uid}',
            headers={'Authorization': f'Bearer {API_TOKEN}'}
        )
        response.raise_for_status()

        payload = response.json()
        source = next(
            (item for item in payload.get('sources', []) if item.get('provider') == provider),
            None
        )

        if source and source.get('data_ready') is True:
            return

        time.sleep(1.5 * attempt)

    raise RuntimeError(f'Export not ready for provider {provider}')

async function getUserSearchHistory(uid: string) {
  const response = await fetch(
    `https://query.emergedata.ai/v1/sync/get_search?uid=${uid}`,
    {
      headers: {
        'Authorization': `Bearer ${API_TOKEN}`
      }
    }
  );

  const data = await response.json();
  return data;
}

// Usage
const searchHistory = await getUserSearchHistory('psub_d4e5f6789012345678901234abcdef01');
console.log(searchHistory.data);
// [{ query: "best restaurants nearby", timestamp: "2024-01-15T10:30:00Z" }, ...]

import requests

def get_user_search_history(uid: str) -> dict:
    response = requests.get(
        f'https://query.emergedata.ai/v1/sync/get_search',
        params={'uid': uid},
        headers={'Authorization': f'Bearer {API_TOKEN}'}
    )
    return response.json()

# Usage
search_history = get_user_search_history('psub_d4e5f6789012345678901234abcdef01')
print(search_history['data'])
# [{'query': 'best restaurants nearby', 'timestamp': '2024-01-15T10:30:00Z'}, ...]