> For the complete documentation index, see [llms.txt](https://docs.pullbay.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.pullbay.com/documentation/support/faq.md).
# FAQ
Welcome to Pullbay! This comprehensive FAQ covers common questions about getting started, billing, integrations, and more.
## Getting Started
What is Pullbay?
Pullbay is a data API platform that provides access to structured data from app stores, social platforms, and other services. Instead of scraping or building complex integrations yourself, Pullbay handles data fetching, normalization, and delivery through a simple REST API.
**Use Pullbay for**:
* App store reviews, ratings, and metadata
* App store analytics and tracking
* App store integrations with n8n, Make.com, and other automation platforms
* Building apps that need app store data
**Why Pullbay over scraping**:
* No scraping required; guaranteed data freshness and legality
* Structured, standardized data format
* Reliable uptime and API support
* Affordable credit-based pricing
Do I need a credit card to sign up?
No. Pullbay offers a free tier with no credit card required. You get a one-time credit allocation to explore the API, with a rate limit of 10 requests per minute. Upgrade to a paid plan when you're ready to scale.
How do I get my API key?
Create a Pullbay accountCreate a Pullbay account at in to your dashboardLog in to your dashboardNavigate to API KeysNavigate to API Keys (usually in the left sidebar)Create a new keyClick Create New KeyName your keyGive your key a name (e.g., "Production", "Test")Copy and store it securelyCopy the key and store it securelyUse it in your API requestsUse in your API requests: Authorization: Bearer your\_api\_key
**Never share your API key**. Treat it like a password. If you accidentally expose it, regenerate immediately from the API Keys page.
What's the difference between test and live keys?
Pullbay provides two types of API keys:
| Type | Prefix | Environment | Data | Credits | Use Case |
| -------- | ------- | ----------- | ------------------ | ------------ | ----------------------------------- |
| **Test** | `test_` | Development | Real data (sample) | Test pool | Development, testing, learning |
| **Live** | `live_` | Production | Real data (full) | Paid credits | Production applications, real usage |
**Same data, different rate limits**:
* Test keys: Lower rate limits for development
* Live keys: Full rate limits matching your plan
**Same credit pool**:
* Requests with both key types deduct from your account credits
* Both count toward your monthly plan usage
**Best practice**:
* Use test keys during development
* Switch to live keys before going to production
* Keep both keys secure
Can I use multiple API keys?
Yes! You can create unlimited API keys from your dashboard:
1. Go to **API Keys** → **Create New Key**
2. Create separate keys for different:
* Applications (web app, mobile app, backend service)
* Team members
* Development stages (development, staging, production)
* Environments
Each key has the same rate limits and credit pool, but allows you to:
* Revoke specific keys without affecting others
* Track usage per application
* Debug issues in isolation
* Rotate keys for security
How do I regenerate an API key?
If you accidentally expose an API key:
Go to API KeysGo to API KeysFind the exposed keyFind the exposed keyRegenerate itClick the three-dot menu → RegenerateOld key becomes invalidThe old key becomes invalid immediatelyUpdate your applicationsUpdate your applications to use the new key
**Important**: Regenerating a key immediately invalidates the old one. Update all applications before regenerating.
***
## Credits & Billing
How does credit billing work?
Pullbay uses a credit-based billing system:
1. **Sign up for a plan**: Choose Free, Starter, Growth, or Scale
2. **Receive credits**: Your plan includes a monthly credit allowance
3. **Use API**: Each successful request deducts credits based on data returned
4. **Top up when needed**: Add credits anytime via dashboard
5. **Renew monthly**: Your plan credits reset on your billing date
**Example**:
* Your plan includes a monthly credit allocation
* You make 10 API requests; each uses credits based on data returned
* Your remaining balance updates immediately after each request
See [Billing Guide](broken://pages/60aff8ad68be852be9bb6479983cca774740de98) for complete details.
Are credits charged for failed requests?
No, you are **not charged for failed requests**:
* **4xx client errors** (400, 401, 404): Not charged (your mistake)
* **5xx server errors** (500, 502, 503): Not charged (our mistake)
* **Rate limit errors** (429): Not charged
* **Timeout errors**: Not charged
**Only successful requests (2xx) deduct credits**.
This encourages reliable API integration. Failed requests don't cost you anything, so focus on building resilience without worrying about credit waste.
Do credits expire?
**Plan credits**: Reset monthly, unused plan credits do NOT roll over
* Your plan includes X credits each month
* On your billing date, they reset to full amount
* Any unused credits from previous month are lost
**Top-up credits**: Never expire
* Credits you purchase manually persist forever
* They're used after plan credits are exhausted
* Carry forward indefinitely until used
**Strategy**: Rely on plan credits for regular usage, purchase top-up credits as a buffer for unexpected spikes.
What happens when I run out of credits?
When your credit balance reaches 0:
* **New requests return 402 Payment Required**
* **Error message**: "Insufficient credits. Add credits to continue."
* **API remains accessible**: No suspension, just can't make requests
* **Your data**: All historical data remains accessible
To resume using the API:
Go to BillingGo to Billing → Add CreditsChoose an amountChoose an amount and complete paymentCredits are addedCredits added immediately (within seconds)Retry your requestsRetry your requests
To prevent this, set up **auto-reload** in billing settings to automatically add credits when balance drops below a threshold.
Can I get a refund for credits?
Credits are non-refundable per Pullbay's Terms of Service. However:
* **Unused credits persist**: They stay in your account indefinitely
* **Technical errors**: If Pullbay made an error, support may credit your account
* **Dispute resolution**: Contact support for special circumstances
For disputes or refund requests, email support with:
* Your account email
* Detailed explanation of the issue
* Transaction IDs if applicable
How much do credits cost?
Credit pricing and top-up amounts are shown in the [Pullbay dashboard](https://app.pullbay.com/) under Billing. See the [Plans guide](broken://pages/3f7fe0ae21de214781d33c3abeb70b1a69c38601) for details on plan-included credit allocations.
Which plan should I choose?
Choose based on your usage pattern:
| Plan | Rate Limit | Best For |
| ----------- | -------------- | ------------------------------ |
| **Free** | 10 req/min | Learning, testing, exploration |
| **Starter** | 60 req/min | Small apps, side projects |
| **Growth** | 300 req/min | Production applications |
| **Scale** | 1,000+ req/min | High-volume, multiple apps |
**Unsure?** Start with the free tier. Upgrade when you need higher rate limits or more monthly credits. See the [Plans guide](broken://pages/3f7fe0ae21de214781d33c3abeb70b1a69c38601) for full details.
***
## Rate Limits
What are the rate limits per plan?
Rate limits specify how many requests you can make per minute:
| Plan | Rate Limit |
| ------- | ------------------------------- |
| Free | 10 requests/minute |
| Starter | 60 requests/minute |
| Growth | 300 requests/minute |
| Scale | 1,000+ requests/minute (custom) |
Rate limits are **per API key**. If you have multiple keys, each has its own limit.
What happens when I hit the rate limit?
When you exceed your rate limit:
1. **HTTP 429 response**: "Too Many Requests"
2. **Headers included**:
* `X-RateLimit-Limit`: Your rate limit (e.g., 60)
* `X-RateLimit-Remaining`: Requests remaining this minute (e.g., 0)
* `X-RateLimit-Reset`: Unix timestamp when limit resets
3. **No credit charge**: Failed requests don't deduct credits
4. **Wait and retry**: After the reset timestamp, try again
**Example response**:
```http
HTTP/1.1 429 Too Many Requests
X-RateLimit-Limit: 60
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1629902400
{"error": "Rate limit exceeded. Retry after 1629902400"}
```
How do I handle rate limits in my code?
Implement **exponential backoff with jitter**:
```python
import requests
import time
def call_with_retry(url, api_key, max_retries=3):
"""Call API with rate limit handling"""
for attempt in range(max_retries):
response = requests.get(
url,
headers={"Authorization": f"Bearer {api_key}"},
timeout=10
)
if response.status_code == 200:
return response.json()
if response.status_code == 429:
# Rate limited; get reset time from header
reset_time = int(response.headers.get('X-RateLimit-Reset', 0))
wait_seconds = reset_time - time.time() + 1 # Add 1 second buffer
print(f"Rate limited. Waiting {wait_seconds}s...")
time.sleep(max(0, wait_seconds))
continue
if response.status_code >= 500:
# Server error; exponential backoff
wait_seconds = 2 ** attempt
print(f"Server error. Retrying in {wait_seconds}s...")
time.sleep(wait_seconds)
continue
response.raise_for_status()
raise Exception("Max retries exceeded")
```
**Better approach: Check headers before hitting limit**:
```python
def call_with_check(url, api_key):
"""Check rate limit before making request"""
response = requests.get(
url,
headers={"Authorization": f"Bearer {api_key}"},
timeout=10
)
if response.status_code == 200:
remaining = int(response.headers.get('X-RateLimit-Remaining', 0))
if remaining < 5:
# Getting close to limit
reset_time = int(response.headers.get('X-RateLimit-Reset', 0))
wait_seconds = reset_time - time.time()
print(f"Rate limit approaching. Next reset in {wait_seconds}s")
# Pause before making more requests
time.sleep(wait_seconds + 1)
return response.json()
response.raise_for_status()
```
Can I request a higher rate limit?
Yes! Options:
1. **Upgrade plan**: Growth plan (300 req/min) or Scale (1,000+ req/min)
2. **Contact sales**: Custom rate limits available for Scale customers
For temporary increases or special cases, email support with:
* Your use case
* Expected peak request volume
* Justification for increase
***
## App Store Service
What App Store data can I access?
Pullbay provides access to:
* **App metadata**: Name, category, release date, version, size, developer info
* **Ratings**: Overall rating, rating distribution (1-5 stars)
* **Reviews**: User reviews, ratings per review, review dates, reviewer info
* **App Store rankings**: Top charts, category rankings
* **Version history**: Release notes and version information
Data is fetched on-demand directly from the App Store, ensuring real-time accuracy.
How do I find an app's ID?
App IDs are numeric identifiers unique to each app. Find them:
**From the App Store URL**:
```
https://apps.apple.com/us/app/instagram/id389801252
↑
App ID: 389801252
```
**Using Pullbay search**:
```python
import requests
response = requests.get(
"https://api.pullbay.com/v1/app-store/reviews",
headers={"Authorization": f"Bearer {api_key}"},
params={"query": "Instagram"}
)
apps = response.json()
# Returns apps with their IDs
for app in apps:
print(f"{app['name']}: {app['id']}")
```
**Common app IDs**:
* Instagram: 389801252
* TikTok: 835599320
* Twitter/X: 333903271
* YouTube: 544007664
What countries are supported for App Store reviews?
Pullbay supports reviews from all major App Store countries using ISO 3166-1 alpha-2 country codes:
**Common countries**:
* US: United States
* GB: United Kingdom
* DE: Germany
* FR: France
* JP: Japan
* AU: Australia
* CA: Canada
* IN: India
**Full list**: Over 150 countries supported. See documentation for complete list.
**How to specify country**:
```python
response = requests.get(
"https://api.pullbay.com/v1/app-store/reviews",
headers={"Authorization": f"Bearer {api_key}"},
params={
"app_id": 389801252,
}
)
```
**Note**: Some countries may have different App Store implementations or reduced data availability.
How fresh is the review data?
**Real-time**: Data is fetched on-demand when you request it
However, there are caveats:
* **App Store caching**: Apple may cache data for hours
* **API processing**: Pullbay processes data to normalize and structure it
* **Typical lag**: 1-24 hours from when review is published to appearing in Pullbay
**For real-time monitoring**: Check the official App Store directly; Pullbay is better for analysis and historical data.
Can I filter reviews by date range?
Yes, use the `since` and `until` parameters:
```python
response = requests.get(
"https://api.pullbay.com/v1/app-store/reviews",
headers={"Authorization": f"Bearer {api_key}"},
params={
"app_id": 389801252,
"since": "2024-01-01",
"until": "2024-03-31"
}
)
```
What's the maximum number of reviews I can fetch?
**Standard endpoint** (`GET /appstore/reviews`): Returns paginated results (e.g., 20 reviews per page)
**Managed endpoint** (`GET /appstore/reviews/all`): Fetches all available reviews (may be thousands)
**Practical limits**:
* Most apps have thousands of reviews
* `/all` endpoints may take 10-30 seconds to complete
* Pagination recommended for large datasets
***
## Pagination
What's the difference between standard and managed pagination?
**Standard endpoints** (you control pagination):
```
GET /appstore/reviews?app_id=389801252&limit=20&offset=0
Returns: First 20 reviews
You decide: How many pages to fetch, when to stop
```
**Managed endpoints** (Pullbay handles pagination):
```
GET /appstore/reviews/all?app_id=389801252
Returns: ALL reviews available
Pullbay decides: Fetches all pages automatically
```
**Comparison**:
| Aspect | Standard | Managed |
| ------------- | ------------------------- | -------------------------- |
| Control | You paginate | Pullbay paginates |
| Speed | Faster (single page) | Slower (all pages) |
| Data volume | Small | Large |
| Use case | Real-time queries | Bulk data, synchronization |
| Code required | More (loop through pages) | Less (single call) |
When should I use /all endpoints?
Use managed `/all` endpoints when:
* **Need all data**: You want every review, rating, etc., not just a sample
* **Bulk operations**: Syncing data to your database
* **Automation workflows**: n8n, Make.com, Zapier integrations
* **Not time-sensitive**: Happy to wait 10-30 seconds for complete data
* **Willing to spend credits**: /all endpoints use more credits (more data)
Use standard endpoints when:
* **Real-time feature**: Showing data to users immediately
* **Paginate yourself**: Loading data as user scrolls
* **Bandwidth-conscious**: Only need sample of data
* **Low latency needed**: Fast response times critical
Can I resume pagination if my request fails?
Yes, use the **cursor** parameter to resume:
```python
response = requests.get(
"https://api.pullbay.com/v1/app-store/reviews",
headers={"Authorization": f"Bearer {api_key}"},
params={
"app_id": 389801252,
"limit": 100,
"cursor": "abc123" # Resume from previous cursor
}
)
```
**How to implement resumable pagination**:
```python
def fetch_all_reviews_resumable(api_key, app_id, save_cursor_fn):
"""Fetch all reviews, saving cursor for resumption"""
cursor = None
all_reviews = []
while True:
try:
params = {"app_id": app_id, "limit": 100}
if cursor:
params["cursor"] = cursor
response = requests.get(
"https://api.pullbay.com/v1/app-store/reviews",
headers={"Authorization": f"Bearer {api_key}"},
params=params,
timeout=10
)
response.raise_for_status()
data = response.json()
all_reviews.extend(data.get("reviews", []))
# Save cursor for resumption
cursor = data.get("next_cursor")
if cursor:
save_cursor_fn(cursor) # Save to file/database
else:
break # No more pages
except Exception as e:
print(f"Error fetching reviews: {e}")
# Next run will resume from saved cursor
break
return all_reviews
```
***
## Integrations
Can I use Pullbay with n8n?
Yes! Pullbay has full n8n integration support:
1. **n8n Node**: Pullbay provides an official n8n node
2. **No code required**: Configure in UI
3. **Workflows**: Build workflows that fetch app data and send to other services
**Basic workflow**:
```
Pullbay (fetch reviews) → Database (store) → Slack (notify)
```
See [n8n Integration Guide](broken://pages/74c946130b63535e63cdfefd580f4acd8acf262a) for setup instructions and examples.
Can I use Pullbay with Make.com?
Guide is in development. For now:
* Use **HTTP module** with Pullbay API directly
* See [API Reference](broken://pages/89c4f858d0ecfea4b36937495663792e4095bc3b) for endpoint details
* Contact support if you need Make.com integration help
A dedicated Make.com module is coming soon.
Can I use Pullbay with Zapier?
Zapier integration documentation is available:
See [Zapier Integration Guide](broken://pages/39ca1a78a1b59337b90ca2c46072563fca83fb94) for setup.
Alternatively, use Zapier's **Webhook** feature to call Pullbay API directly.
Should I call Pullbay from client-side code?
**No, never from client-side code** (JavaScript in browser):
**Why not**:
* API key would be visible in browser DevTools
* Anyone could steal your API key and use your credits
* Rate limits would be shared with all users
* Poor security practice
**What to do instead**:
1. **Call from backend**: Your server calls Pullbay API
2. **Return to frontend**: Server returns processed data to browser
3. **Your server controls access**: Authenticate users before returning data
**Architecture**:
```
Browser → Your backend → Pullbay API → Browser
```
**Code example** (Node.js backend):
```javascript
// backend/api.js
app.get('/api/app-reviews/:appId', async (req, res) => {
// API key stored securely in environment variable
const apiKey = process.env.PULLBAY_API_KEY;
const response = await fetch('https://api.pullbay.com/v1/app-store/reviews', {
headers: {
'Authorization': `Bearer ${apiKey}`
},
params: {
app_id: req.params.appId
}
});
res.json(await response.json());
});
```
```javascript
// frontend/index.js
// Never expose API key here!
fetch('/api/app-reviews/389801252')
.then(r => r.json())
.then(data => console.log(data));
```
***
## Security & Compliance
Is the data Pullbay provides legal to use?
**TL;DR**: The data is public, but you're responsible for legal compliance.
Pullbay provides access to **publicly available data** from app stores and public APIs. However:
* **You're responsible**: Ensure your use complies with terms of service and laws
* **Check terms**: Review App Store terms and any restrictions on data use
* **Jurisdiction matters**: Laws vary by country and use case
* **Commercial use**: May have different restrictions than personal use
**Generally legal uses**:
* Analytics and reporting
* App monitoring and tracking
* Market research
* Competitor analysis
* Content moderation (using review data to improve your app)
**Potentially problematic uses**:
* Violating app store terms of service
* Scraping/copying reviews word-for-word
* Impersonating users
* Selling user data
* Building competing products that copy data
**Always**:
1. Review app store terms of service
2. Consult your legal team for commercial use
3. Respect user privacy and intellectual property
4. Don't violate any platform's terms
See [Data Usage Policy](broken://pages/db4806f0bf7430ca87a2532695c5bb97d8ba16cf) for Pullbay's specific policies.
How do I keep my API key secure?
**Essential practices**:
Store in environment variablesStore in environment variables (never in code):import osapi\_key = os.environ\['PULLBAY\_API\_KEY']Use .env filesUse .env files (development only, never commit):# .envPULLBAY\_API\_KEY=live\_xxxxxxxxxxxxfrom dotenv import load\_dotenvload\_dotenv()api\_key = os.getenv('PULLBAY\_API\_KEY')Configure in your hosting platformConfigure in hosting platform (production):Heroku: Config variablesAWS: Secrets Manager, Parameter StoreGoogle Cloud: Secret ManagerDocker: Secrets, environment injectionRotate regularlyRotate regularly: Regenerate keys monthly/quarterlyUse least privilegePrinciple of least privilege: Create keys for specific purposes:Separate keys for different applicationsEach key for one environment (dev, staging, prod)Revoke unused keysNever do the followingNever:Commit to version controlShare in email or SlackUse in client-side codeHardcode in source code
Does Pullbay store my data?
No, Pullbay does **not store** the data you fetch:
* **Fetched on-demand**: Data retrieved from upstream sources in real-time
* **Not cached**: Each request fetches fresh data
* **No persistent storage**: Data not saved in Pullbay databases
* **Metadata only**: Pullbay stores only usage metrics, not data content
**Data flow**:
```
You → Pullbay → App Store → Pullbay → You
(API call) (data fetch) (response)
Data never persisted in Pullbay
```
**What Pullbay does store**:
* API usage logs (for billing and analytics)
* Request timestamps and status codes
* Aggregated metrics (success rate, latency)
**Data retention**: Usage logs retained for billing and support purposes (typically 90 days).
***
## Support
How do I contact support?
**Email**:
**Include in support request**:
* Your request ID (if API error)
* API key prefix (e.g., live\_abc...)
* Endpoint being called
* Error message or unexpected behavior
* Steps to reproduce
* Expected vs. actual result
**Response times**:
* Free tier: 2-3 business days
* Starter/Growth: 24 hours
* Scale: 2 hours (during business hours)
What should I include in a support request?
**Effective support requests** include:
Request IDRequest ID: From HTTP response header X-Request-IDcurl -i \ -H "Authorization: Bearer live\_xxx"# Look for: X-Request-ID: req\_abc123...API key prefixAPI key prefix: First few characters onlyExample: "live\_abc..." (never send full key)EndpointEndpoint: Full URL being calledExample: GET /appstore/reviews?app\_id=389801252\&country=USError messageError message: Complete error textInclude full HTTP status and response bodyCode contextCode context: (Optional) Simplified code snippet showing how you're calling the APIReproduction stepsReproduction steps: How to reproduce the issueCreate app XCall endpoint YObserve error Z
**Example support request**:
```
Subject: 402 error on reviews endpoint
Request ID: req_abc123def456
API key: live_xyz...
Endpoint: GET /appstore/reviews?app_id=389801252
Error: HTTP 402 Payment Required
Response: {"error": "Insufficient credits"}
Steps to reproduce:
1. Made 100 API requests this morning
2. All succeeded until request #95
3. Request #95 returned 402 error
4. All subsequent requests also return 402
Expected: Requests should succeed or return clear error with remaining balance
Actual: Getting 402 errors even though I thought I had credits remaining
Can you help me understand what happened?
```
This gives support everything needed to help quickly.
How long does it take to get a response?
**Response time SLA**:
| Plan | Email Response Time |
| ------- | ------------------------ |
| Free | 2-3 business days |
| Starter | 1 business day |
| Growth | 24 hours |
| Scale | 2 hours (business hours) |
**Outside business hours**: Responses may be delayed for non-emergency issues.
What if I have an emergency issue?
For critical production issues:
Email support immediatelyEmail support immediately with "URGENT" in subjectInclude the followingInclude:Request IDs showing the issueCurrent customer impact (how many users affected)Business impactWorkaround statusScale customersFor Scale customers: May have phone number for critical issues (ask your account manager)
***
## Troubleshooting
I'm getting 401 Unauthorized
**Cause**: Authentication failed
**Check**:
* API key is correct: Copy from Dashboard → API Keys
* API key has correct prefix: `test_` or `live_`
* Header format correct: `Authorization: Bearer YOUR_KEY` (note the space)
* Key not regenerated: If you regenerated a key, update your code
**Fix**:
```python
import requests
# Correct
headers = {"Authorization": "Bearer live_abc123..."}
response = requests.get(url, headers=headers)
# Wrong
headers = {"Authorization": "live_abc123..."} # Missing "Bearer"
headers = {"Authorization": f"Bearer {api_key}"} # If api_key is wrong
```
I'm getting 402 Payment Required
**Cause**: Insufficient credits
**Check**:
* Current credit balance in Dashboard → Billing
* How many credits used this month
* Credit top-ups pending
**Fix**:
1. Add credits: Dashboard → Billing → Add Credits
2. Or upgrade plan for more monthly credits
3. Or enable auto-reload to prevent future outages
I'm getting 429 Too Many Requests
**Cause**: Hit your rate limit
**Check**:
* Current rate limit: Dashboard shows it for your plan
* How many requests per minute you're making
* Are multiple applications using same API key?
**Fix**:
1. Slow down: Wait before making more requests
2. Implement exponential backoff (see [Rate Limits](#rate-limits))
3. Upgrade to higher plan for more requests/minute
4. Use separate API keys for different apps
I'm getting 5xx Server Errors
**Cause**: Pullbay server issue (our problem, not yours)
**What to do**:
1. Check status page:
2. Implement retry logic with exponential backoff
3. Contact support if errors persist
4. Include Request ID from error response
Requests are timing out
**Cause**: Requests taking longer than your timeout
**Check**:
* Current timeout setting: Is it at least 2× p95 response time?
* Pullbay status: Check status.pullbay.com for any degradation
* Your network: Is your internet connection slow?
* Endpoint type: Managed endpoints (`/all`) are slower than standard
**Fix**:
```python
# Increase timeout
response = requests.get(url, timeout=30) # 30 seconds instead of 10
# Or check response time from Dashboard → Analytics → Metrics
# Recommended timeout = 2 × p95 response time shown
```
Requests are slow
**Cause**: High latency
**Check**:
* p95 response time from Dashboard → Analytics → Metrics
* Endpoint type: Are you using managed endpoints (slower)?
* Time of day: Peak hours may be slower
* Pullbay status: Any degradation indicated?
**Recommendations**:
* Schedule bulk requests during off-peak hours
* Use pagination for large datasets (don't fetch all at once)
* Monitor latency trends over time
* Contact support if degradation persists
I'm getting different data on different requests
**Cause**: Data is fetched fresh each time; upstream data changes
**Why**:
* Pullbay fetches from App Store on each request (not cached)
* App Store data may change between requests
* New reviews posted constantly
* Ratings updated
**Solution**:
* This is normal behavior
* If you need consistent snapshots, store data locally
* For analytics, use managed endpoints to get complete datasets at one point in time
***
## Miscellaneous
How do I report a bug?
Report bugs by emailing support with:
1. Description of unexpected behavior
2. Steps to reproduce
3. Expected behavior
4. Actual behavior
5. Request IDs (if applicable)
6. Your Pullbay plan/key prefix
Include as much detail as possible to help us investigate.
Can I request a feature?
Absolutely! Email support or use the feedback form in your dashboard to suggest features.
**Include**:
* Feature description
* Use case / why you need it
* How it would improve your workflow
Feedback helps us prioritize development.
Is there a Slack community or forum?
Not currently, but you can:
* Follow Pullbay on social media for updates
* Subscribe to status page for incident notifications
* Email support for questions and discussions
Where can I find API documentation?
* **Full API Reference**: [/docs/api-reference.md](broken://pages/89c4f858d0ecfea4b36937495663792e4095bc3b)
* **Integration guides**: [/docs/integrations/](broken://pages/9828d7ff7130560d44381da963b79b2ac1bb1b67)
* **Best practices**: [/docs/best-practices.md](broken://pages/3e57646d1da08dd55ed8bc64285a4b3ab001ec5a)
* **Error codes**: [/docs/error-handling.md](broken://pages/46c54e02407254e7b23c431c14a6a5219cacdac9)
How often is Pullbay updated?
Pullbay releases updates continuously:
* **API endpoints**: New endpoints added regularly
* **Data sources**: New data sources added quarterly
* **Bug fixes**: Deployed continuously
* **Feature releases**: Monthly
You'll be notified of major updates via:
* Status page announcements
* Dashboard notifications
* Email updates (if subscribed)
What's the Pullbay roadmap?
Check the [Pullbay Roadmap](broken://pages/2e673e882666e0781cfbeafe29a34d217e87ce75) for planned features and improvements (updated quarterly).
How do I stay updated?
Subscribe to:
* **Status page**: (incidents and maintenance)
* **Email notifications**: Dashboard → Settings → Email Preferences
* **Release notes**: Check blog or changelog for updates
***
## Still have questions?
Didn't find an answer? Contact support:
* **Email**:
* **Response time**: Depends on your plan (see Support section)
* **Include request ID**: Speeds up resolution
We're here to help!
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.pullbay.com/documentation/support/faq.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.