How to Integrate Replit with Quora Ads

1import os
2import requests
3
4def exchange_code_for_token(auth_code: str, redirect_uri: str) -> dict:
5    """
6    Exchange an OAuth authorization code for access and refresh tokens.
7    Run this once after completing the OAuth flow in a browser.
8    """
9    token_url = "https://www.quora.com/ads/api/oauth/token"
10    data = {
11        "grant_type": "authorization_code",
12        "code": auth_code,
13        "client_id": os.environ["QUORA_CLIENT_ID"],
14        "client_secret": os.environ["QUORA_CLIENT_SECRET"],
15        "redirect_uri": redirect_uri
16    }
17    response = requests.post(token_url, data=data)
18    response.raise_for_status()
19    token_data = response.json()
20    print("Access token obtained. Store in Replit Secrets as QUORA_ACCESS_TOKEN:")
21    print(token_data.get('access_token', '')[:30] + '...')
22    return token_data
23
24def refresh_access_token() -> str:
25    """Refresh the access token using the stored refresh token."""
26    token_url = "https://www.quora.com/ads/api/oauth/token"
27    data = {
28        "grant_type": "refresh_token",
29        "refresh_token": os.environ["QUORA_REFRESH_TOKEN"],
30        "client_id": os.environ["QUORA_CLIENT_ID"],
31        "client_secret": os.environ["QUORA_CLIENT_SECRET"]
32    }
33    response = requests.post(token_url, data=data)
34    response.raise_for_status()
35    new_token = response.json()['access_token']
36    print("Token refreshed. Update QUORA_ACCESS_TOKEN in Replit Secrets.")
37    return new_token
38
39if __name__ == "__main__":
40    # Step 1: Build the authorization URL
41    auth_url = (
42        "https://www.quora.com/ads/api/oauth"
43        "?client_id=" + os.environ.get('QUORA_CLIENT_ID', 'YOUR_CLIENT_ID') +
44        "&redirect_uri=https://your-app.replit.app/auth/callback"
45        "&response_type=code"
46        "&scope=read+write"
47    )
48    print("1. Open this URL in your browser:", auth_url)
49    print("2. After authorizing, paste the 'code' from the redirect URL:")
50    auth_code = input("Authorization code: ")
51    tokens = exchange_code_for_token(auth_code, "https://your-app.replit.app/auth/callback")
52    print("Store in Secrets: QUORA_ACCESS_TOKEN =", tokens.get('access_token'))

1import os
2import requests
3from datetime import datetime, timedelta
4
5ACCESS_TOKEN = os.environ["QUORA_ACCESS_TOKEN"]
6AD_ACCOUNT_ID = os.environ["QUORA_AD_ACCOUNT_ID"]
7BASE_URL = "https://www.quora.com/ads/api/v1"
8
9HEADERS = {
10    "Authorization": f"Bearer {ACCESS_TOKEN}",
11    "Content-Type": "application/json"
12}
13
14def get_ad_account() -> dict:
15    """Fetch ad account details to verify API access."""
16    url = f"{BASE_URL}/ad_account/{AD_ACCOUNT_ID}"
17    response = requests.get(url, headers=HEADERS)
18    if response.status_code == 401:
19        raise ValueError("Invalid or expired access token. Re-run OAuth flow.")
20    response.raise_for_status()
21    return response.json()
22
23def get_campaigns(status: str = None) -> list:
24    """
25    Fetch campaigns for the ad account.
26    status options: 'ACTIVE', 'PAUSED', 'ARCHIVED'
27    """
28    url = f"{BASE_URL}/ad_account/{AD_ACCOUNT_ID}/campaigns"
29    params = {}
30    if status:
31        params['status'] = status
32    response = requests.get(url, headers=HEADERS, params=params)
33    response.raise_for_status()
34    data = response.json()
35    return data.get('campaigns', data.get('data', []))
36
37def get_campaign_insights(
38    campaign_id: str,
39    start_date: str,
40    end_date: str
41) -> dict:
42    """
43    Get performance insights for a campaign.
44    Dates in YYYY-MM-DD format.
45    """
46    url = f"{BASE_URL}/campaign/{campaign_id}/insights"
47    params = {
48        "start_date": start_date,
49        "end_date": end_date,
50        "metrics": "impressions,clicks,spend,conversions,ctr,cpc"
51    }
52    response = requests.get(url, headers=HEADERS, params=params)
53    response.raise_for_status()
54    return response.json()
55
56def get_account_insights(days: int = 30) -> dict:
57    """Get aggregate account-level performance for the past N days."""
58    end_date = datetime.now().strftime("%Y-%m-%d")
59    start_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
60    url = f"{BASE_URL}/ad_account/{AD_ACCOUNT_ID}/insights"
61    params = {
62        "start_date": start_date,
63        "end_date": end_date,
64        "metrics": "impressions,clicks,spend,conversions"
65    }
66    response = requests.get(url, headers=HEADERS, params=params)
67    response.raise_for_status()
68    return response.json()
69
70def pause_campaign(campaign_id: str) -> dict:
71    """Pause a campaign to stop spend."""
72    url = f"{BASE_URL}/campaign/{campaign_id}"
73    response = requests.patch(
74        url,
75        json={"status": "PAUSED"},
76        headers=HEADERS
77    )
78    response.raise_for_status()
79    return response.json()
80
81# Example usage
82if __name__ == "__main__":
83    # Verify API access
84    account = get_ad_account()
85    print(f"Ad account: {account.get('name', AD_ACCOUNT_ID)}")
86
87    # List campaigns
88    campaigns = get_campaigns(status='ACTIVE')
89    print(f"Active campaigns: {len(campaigns)}")
90    for c in campaigns[:3]:
91        print(f"  [{c.get('id')}] {c.get('name')} — Budget: {c.get('daily_budget', 'N/A')}")
92
93    # Account-level insights
94    insights = get_account_insights(30)
95    print(f"\n30-day account stats: {insights}")

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const ACCESS_TOKEN = process.env.QUORA_ACCESS_TOKEN;
8const AD_ACCOUNT_ID = process.env.QUORA_AD_ACCOUNT_ID;
9const BASE_URL = 'https://www.quora.com/ads/api/v1';
10
11const quoraApi = axios.create({
12  baseURL: BASE_URL,
13  headers: {
14    'Authorization': `Bearer ${ACCESS_TOKEN}`,
15    'Content-Type': 'application/json'
16  }
17});
18
19// Get all campaigns for the account
20app.get('/campaigns', async (req, res) => {
21  try {
22    const response = await quoraApi.get(`/ad_account/${AD_ACCOUNT_ID}/campaigns`, {
23      params: req.query.status ? { status: req.query.status.toUpperCase() } : {}
24    });
25    const campaigns = response.data.campaigns || response.data.data || [];
26    res.json(campaigns);
27  } catch (err) {
28    console.error('Campaigns error:', err.response?.data);
29    res.status(err.response?.status || 500).json({
30      error: err.response?.data?.message || err.message
31    });
32  }
33});
34
35// Get performance insights for a date range
36// Query params: startDate (YYYY-MM-DD), endDate (YYYY-MM-DD), level (account|campaign)
37app.get('/insights', async (req, res) => {
38  const { startDate, endDate, level = 'account' } = req.query;
39  if (!startDate || !endDate) {
40    return res.status(400).json({ error: 'startDate and endDate are required (YYYY-MM-DD)' });
41  }
42
43  try {
44    const endpoint = level === 'account'
45      ? `/ad_account/${AD_ACCOUNT_ID}/insights`
46      : `/ad_account/${AD_ACCOUNT_ID}/campaigns`;
47
48    const response = await quoraApi.get(endpoint, {
49      params: {
50        start_date: startDate,
51        end_date: endDate,
52        metrics: 'impressions,clicks,spend,conversions,ctr,cpc'
53      }
54    });
55    res.json(response.data);
56  } catch (err) {
57    res.status(err.response?.status || 500).json({
58      error: err.response?.data?.message || err.message
59    });
60  }
61});
62
63// Pause or resume a campaign
64app.patch('/campaigns/:id/status', async (req, res) => {
65  const { status } = req.body;
66  if (!['ACTIVE', 'PAUSED'].includes(status?.toUpperCase())) {
67    return res.status(400).json({ error: 'status must be ACTIVE or PAUSED' });
68  }
69  try {
70    const response = await quoraApi.patch(`/campaign/${req.params.id}`, {
71      status: status.toUpperCase()
72    });
73    res.json({ success: true, id: req.params.id, status: status.toUpperCase() });
74  } catch (err) {
75    res.status(err.response?.status || 500).json({ error: err.message });
76  }
77});
78
79// Get ad account summary
80app.get('/account', async (req, res) => {
81  try {
82    const response = await quoraApi.get(`/ad_account/${AD_ACCOUNT_ID}`);
83    res.json(response.data);
84  } catch (err) {
85    res.status(err.response?.status || 500).json({ error: err.message });
86  }
87});
88
89app.listen(3000, '0.0.0.0', () => {
90  console.log('Quora Ads integration server running on port 3000');
91});

1import os
2import requests
3from datetime import datetime
4
5def refresh_quora_token() -> str:
6    """
7    Refresh expired Quora Ads access token using the stored refresh token.
8    Returns the new access token.
9    Call this when API requests return 401.
10    """
11    token_url = "https://www.quora.com/ads/api/oauth/token"
12    data = {
13        "grant_type": "refresh_token",
14        "refresh_token": os.environ["QUORA_REFRESH_TOKEN"],
15        "client_id": os.environ["QUORA_CLIENT_ID"],
16        "client_secret": os.environ["QUORA_CLIENT_SECRET"]
17    }
18    response = requests.post(token_url, data=data)
19    if response.status_code != 200:
20        raise ValueError(
21            f"Token refresh failed ({response.status_code}). "
22            "Re-run the full OAuth flow using get_token.py."
23        )
24    new_data = response.json()
25    new_token = new_data['access_token']
26    print(f"Token refreshed at {datetime.now()}")
27    print(f"New token (first 20 chars): {new_token[:20]}...")
28    print("IMPORTANT: Update QUORA_ACCESS_TOKEN in Replit Secrets with this value.")
29    return new_token
30
31def make_api_request_with_retry(url: str, headers: dict, params: dict = None) -> dict:
32    """Make a Quora API request, refreshing the token on 401."""
33    response = requests.get(url, headers=headers, params=params)
34    if response.status_code == 401:
35        print("Token expired, attempting refresh...")
36        new_token = refresh_quora_token()
37        headers['Authorization'] = f'Bearer {new_token}'
38        response = requests.get(url, headers=headers, params=params)
39    response.raise_for_status()
40    return response.json()
41
42if __name__ == "__main__":
43    try:
44        new_token = refresh_quora_token()
45    except Exception as e:
46        print(f"Refresh failed: {e}")
47        print("Re-run get_token.py to complete a fresh OAuth authorization.")