Documentation

// Required headers for all requests
{
  "X-RapidAPI-Key": "your-api-key-here",
  "X-RapidAPI-Host": "api-host-here"
}

// JavaScript — look up a property by BBL
const response = await fetch(
  'https://new-york-city-violation-alerts.p.rapidapi.com/lookup?bbl=1004777501',
  {
    headers: {
      'X-RapidAPI-Key': 'your-api-key',
      'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
    }
  }
);
const data = await response.json();
// data.property  — PLUTO fields (address, borough, year_built, …)
// data.violations / data.complaints / data.permits — arrays
// data.summary   — { violation_count, complaint_count, permit_count }

# Python — look up a property by address
import requests

response = requests.get(
    'https://new-york-city-violation-alerts.p.rapidapi.com/lookup',
    params={'address': '350 Fifth Ave'},
    headers={
        'X-RapidAPI-Key': 'your-api-key',
        'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
    }
)
data = response.json()
print(data['property']['bbl'])
print(data['summary'])

// Successful response
{
  "status": "success",
  "count": 10,
  "data": [...],
  "pagination": {
    "page": 1,
    "limit": 50,
    "total": 100
  }
}

// Error response
{
  "status": "error",
  "code": "INVALID_PARAMETER",
  "message": "The 'address' parameter is required."
}

// JavaScript
const response = await fetch(
  'https://new-york-city-violation-alerts.p.rapidapi.com/search?q=Empire+State&borough=MANHATTAN&limit=5',
  {
    headers: {
      'X-RapidAPI-Key': 'your-api-key',
      'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
    }
  }
)
const data = await response.json()
// data.properties — array of matching property objects
// data.count      — total matched

# Python
import requests

r = requests.get(
    'https://new-york-city-violation-alerts.p.rapidapi.com/search',
    params={'q': 'Empire State', 'borough': 'MANHATTAN', 'limit': 5},
    headers={
        'X-RapidAPI-Key': 'your-api-key',
        'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
    }
)
data = r.json()
for prop in data['properties']:
    print(prop['bbl'], prop['address'])

// JavaScript — poll for new violations every hour
const BBL = '1004777501'
let lastPoll = new Date(Date.now() - 3600_000).toISOString() // 1 hour ago

async function pollChanges() {
  const url = new URL('https://new-york-city-violation-alerts.p.rapidapi.com/changes')
  url.searchParams.set('bbl', BBL)
  url.searchParams.set('since', lastPoll)

  const res = await fetch(url, {
    headers: {
      'X-RapidAPI-Key': 'your-api-key',
      'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
    }
  })

  const data = await res.json()

  if (data.violation_count > 0 || data.complaint_count > 0) {
    console.log(`${data.violation_count} new violations, ${data.complaint_count} new complaints`)
    // handle data.violations, data.complaints, data.permits ...
  }

  lastPoll = new Date().toISOString()
}

setInterval(pollChanges, 60 * 60 * 1000) // every hour

# Python — poll for new violations
import requests
from datetime import datetime, timedelta, timezone

BBL = '1004777501'
last_poll = (datetime.now(timezone.utc) - timedelta(hours=1)).isoformat()

def poll_changes():
    global last_poll
    response = requests.get(
        'https://new-york-city-violation-alerts.p.rapidapi.com/changes',
        params={'bbl': BBL, 'since': last_poll},
        headers={
            'X-RapidAPI-Key': 'your-api-key',
            'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
        }
    )
    data = response.json()

    if data['violation_count'] > 0 or data['complaint_count'] > 0:
        print(f"{data['violation_count']} new violations")
        # process data['violations'], data['complaints'], data['permits']

    last_poll = datetime.now(timezone.utc).isoformat()

// JavaScript — find all properties owned by an LLC
const response = await fetch(
  'https://new-york-city-violation-alerts.p.rapidapi.com/landlord?owner=STUY+TOWN&limit=100',
  {
    headers: {
      'X-RapidAPI-Key': 'your-api-key',
      'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
    }
  }
)
const data = await response.json()
// data.owner_query — normalized search term
// data.count       — number of matching properties
// data.properties  — array of property objects with PLUTO fields

# Python — portfolio lookup for a landlord
import requests

r = requests.get(
    'https://new-york-city-violation-alerts.p.rapidapi.com/landlord',
    params={'owner': 'BLACKSTONE', 'limit': 200},
    headers={
        'X-RapidAPI-Key': 'your-api-key',
        'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
    }
)
data = r.json()
for prop in data['properties']:
    print(prop['bbl'], prop['address'], prop['assessed_total_value'])

// JavaScript — render a property history feed
const response = await fetch(
  'https://new-york-city-violation-alerts.p.rapidapi.com/timeline?bbl=1000477501',
  {
    headers: {
      'X-RapidAPI-Key': 'your-api-key',
      'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
    }
  }
)
const { timeline, event_count } = await response.json()
console.log(`${event_count} events`)
for (const event of timeline) {
  // event.type        — 'violation' | 'complaint' | 'permit'
  // event.date        — ISO date string (or null)
  // event.title       — short label (violation_type, complaint_type, permit_type)
  // event.description — longer description
  // event.status      — current status
  console.log(event.date, event.type, event.title)
}

# Python — due diligence timeline for a BBL
import requests

r = requests.get(
    'https://new-york-city-violation-alerts.p.rapidapi.com/timeline',
    params={'bbl': '1000477501'},
    headers={
        'X-RapidAPI-Key': 'your-api-key',
        'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
    }
)
data = r.json()
for event in data['timeline']:
    print(f"[{event['type']}] {event['date']} — {event['title']}")

// JavaScript — site selection analytics for a zip code
const response = await fetch(
  'https://new-york-city-violation-alerts.p.rapidapi.com/neighborhood?zip_code=10001',
  {
    headers: {
      'X-RapidAPI-Key': 'your-api-key',
      'X-RapidAPI-Host': 'new-york-city-violation-alerts.p.rapidapi.com'
    }
  }
)
const data = await response.json()
// data.pluto_summary.total_properties    — all properties in zip (from PLUTO)
// data.pluto_summary.avg_assessed_total_value
// data.violation_rate  — avg violations per cached property
// data.top_violation_types  — [{ type, count }, ...]

# Python — compare neighborhoods by violation rate
import requests

HOST = 'new-york-city-violation-alerts.p.rapidapi.com'
HEADERS = {
    'X-RapidAPI-Key': 'your-api-key',
    'X-RapidAPI-Host': HOST
}

for zip_code in ['10001', '10002', '10003']:
    r = requests.get(
        f'https://{HOST}/neighborhood',
        params={'zip_code': zip_code},
        headers=HEADERS
    )
    d = r.json()
    print(f"{zip_code}: {d['violation_rate']} violations/property, "
          f"{d['pluto_summary'].get('total_properties')} total properties")

// JavaScript — who owns this property?
const response = await fetch(
  'https://national-property-owner-lookup.p.rapidapi.com/owner/lookup?address=350+5+Avenue&county=nyc',
  {
    headers: {
      'X-RapidAPI-Key': 'your-api-key',
      'X-RapidAPI-Host': 'national-property-owner-lookup.p.rapidapi.com'
    }
  }
)
const data = await response.json()
// data.results — array of normalized owner records
// each record: owner_name, address, parcel_id, assessed_value,
//              year_built, owner_mailing_address, owner_occupied

# Python — skip-trace every property an LLC owns
import requests

HOST = 'national-property-owner-lookup.p.rapidapi.com'
r = requests.get(
    f'https://{HOST}/owner/portfolio',
    params={'name': 'CENTRAL CAPITAL GROUP', 'county': 'philadelphia', 'limit': 200},
    headers={
        'X-RapidAPI-Key': 'your-api-key',
        'X-RapidAPI-Host': HOST
    }
)
data = r.json()
for prop in data['results']:
    print(prop['address'], '—', prop['owner_mailing_address'])

// JavaScript — find an LLC by name
const response = await fetch(
  'https://us-business-entity-lookup.p.rapidapi.com/entity/search?name=EMPIRE+STATE+REALTY&state=ny',
  {
    headers: {
      'X-RapidAPI-Key': 'your-api-key',
      'X-RapidAPI-Host': 'us-business-entity-lookup.p.rapidapi.com'
    }
  }
)
const data = await response.json()
// data.results — array of normalized entity records
// each record: entity_name, entity_type, status, formation_date,
//              jurisdiction, county, registered_agent, registered_agent_address

# Python — resolve a single entity by its registry ID
import requests

HOST = 'us-business-entity-lookup.p.rapidapi.com'
r = requests.get(
    f'https://{HOST}/entity/lookup',
    params={'registry_id': '4424185', 'state': 'ny'},
    headers={
        'X-RapidAPI-Key': 'your-api-key',
        'X-RapidAPI-Host': HOST
    }
)
entity = r.json()
print(entity['entity_name'], '—', entity['status'])
print('Registered agent:', entity['registered_agent_address'])

// JavaScript — screenshot a page and pass it to a vision model
const response = await fetch(
  'https://website-screenshot.p.rapidapi.com/screenshot?url=https%3A%2F%2Fexample.com&full_page=true',
  {
    headers: {
      'X-RapidAPI-Key': 'your-api-key',
      'X-RapidAPI-Host': 'website-screenshot.p.rapidapi.com'
    }
  }
)
const data = await response.json()
// data.title      — page <title> text
// data.screenshot — base64-encoded PNG/JPEG string
// data.format     — 'png' or 'jpeg'
// data.url        — the URL that was screenshotted

// Decode and save to disk (Node.js)
const fs = require('fs')
fs.writeFileSync('screenshot.png', Buffer.from(data.screenshot, 'base64'))

# Python — screenshot a page and feed it to GPT-4o or Claude
import requests, base64, openai

HOST = 'website-screenshot.p.rapidapi.com'
r = requests.get(
    f'https://{HOST}/screenshot',
    params={'url': 'https://example.com', 'full_page': 'true', 'width': '1280'},
    headers={
        'X-RapidAPI-Key': 'your-api-key',
        'X-RapidAPI-Host': HOST
    }
)
data = r.json()

# Save to disk
with open('screenshot.png', 'wb') as f:
    f.write(base64.b64decode(data['screenshot']))

# Or pass straight to a vision model
client = openai.OpenAI()
reply = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': [
            {'type': 'text', 'text': 'Describe the design and layout of this page.'},
            {'type': 'image_url', 'image_url': {
                'url': f"data:image/{data['format']};base64,{data['screenshot']}"
            }}
        ]
    }]
)
print(reply.choices[0].message.content)