This post shows how to pull every solar permit issued in the last 30 days from official open-data APIs, with one short Python script. No login, no scraping, no API key.

Run on Oct 22, 2026, the script found:

• San Diego County (unincorporated): 260 solar permits in 30 days, mostly residential roof-mount PV through the county's online "HRA" express permit, plus ground-mount, commercial and battery (energy storage) permits.
• Corona, CA: 32 solar permits, almost all labeled "SOLAR WITH ESS" (solar plus a home battery).

The data sources

Both run on Socrata, so you query them with plain HTTP and SoQL (a SQL-like query language passed as URL parameters).

The script

import requests
from datetime import date, timedelta
since = (date.today() - timedelta(days=30)).isoformat()
SOURCES = [  # (label, domain, dataset, date field, text fields to search)
    ("San Diego County", "data.sandiegocounty.gov", "red2-qccu", "issued_date", ["use", "primary_scope_code", "record_category"]),
    ("Corona", "corstat.coronaca.gov", "2agx-camz", "issued", ["description", "permitsubtype"]),
]
def solar(label, domain, ds, dfield, fields):
    like = " OR ".join(f"upper({f}) like '%SOLAR%' OR upper({f}) like '%PHOTOVOLTAIC%' OR upper({f}) like '%PV%'" for f in fields)
    r = requests.get(f"https://{domain}/resource/{ds}.json", params={
        "$where": f"{dfield} >= '{since}' AND ({like})", "$order": f"{dfield} DESC", "$limit": 5000}, timeout=120)
    r.raise_for_status(); return r.json()
for s in SOURCES:
    rows = solar(*s)
    print(f"{s[0]}: {len(rows)} solar permits since {since}")
    for r in rows[:3]:
        print("  ", r.get("issued_date") or r.get("issued"), r.get("full_address") or r.get("site_addr"), "|", (r.get("use") or r.get("description") or "")[:70].replace("\n", " "))

Three things that will trip you up

1. "Solar" isn't always in the same column. San Diego County puts the clearest signal in primary_scope_code (for example 8002 - REN - Solar Photovoltaic Roof Mount Residential - Online), while the free-text use column holds the work description. Search both, as the script does.
2. Search for PV, not just "solar". Many permits say "PV" or "photovoltaic" and never use the word solar. The script matches %PV% too. Spot-check the results: in a few datasets PV can show up inside unrelated words.
3. Batteries are their own leads. San Diego County issues separate "Advanced Energy Storage System" permits. If you sell batteries or backup power, search for ENERGY STORAGE or ESS on their own.

Turning it into a lead list

• Run it weekly with timedelta(days=7) and de-duplicate on the permit number.
• New solar owners are a fit for battery add-ons, critter guards, panel cleaning, monitoring and home insurance reviews. Mail or door-hang by address. Don't try to look up the homeowners: the address and permit are enough.
• To find the busiest installers, group by the contractor column where a city publishes one.
• The same pattern works anywhere a city publishes permits on Socrata: change the domain, dataset ID and field names.

Optional: if you'd rather not maintain this, I run it as a hosted, scheduled search covering California and other states: California Solar Permits (ready-made search) (paid per result). Disclosure: it's my tool. The script above does the same job for free.

There's an easier route: SAM.gov publishes every contract opportunity as a free daily CSV file, with no key and no login. This post shows how to stream it in Python and pull just the set-asides you qualify for.

Run on Oct 22, 2026, for notices posted in the last 7 days:

• 6,156 notices were posted in total.
• 1,228 were total small-business set-asides and 240 were SDVOSB set-asides.
• 57 were HUBZone set-asides, 38 were 8(a) set-asides plus 13 8(a) sole-source notices, and 34 were WOSB or EDWOSB set-asides.
• 3,880 had no set-aside at all.

The data source

Contract Opportunities full extract, published by GSA through data.gov and refreshed daily. It's about 200 MB, Windows-1252 encoded, with one row per notice, and it's sorted newest first. That last part is the trick: you only need to read the first few thousand rows.

The script

import csv, io, sys, requests
from collections import Counter
from datetime import date, timedelta
csv.field_size_limit(sys.maxsize)
URL = "https://s3.amazonaws.com/falextracts/Contract%20Opportunities/datagov/ContractOpportunitiesFullCSV.csv"
DAYS = 7
since = (date.today() - timedelta(days=DAYS)).isoformat()

def recent_opportunities():
    """Stream SAM.gov's public daily extract (about 200 MB, newest first) and stop once rows get older than the window."""
    with requests.get(URL, stream=True, timeout=300) as r:
        r.raise_for_status()
        r.raw.decode_content = True
        reader = csv.DictReader(io.TextIOWrapper(r.raw, encoding="cp1252", errors="replace", newline=""))
        older = 0
        for row in reader:
            if row["PostedDate"][:10] >= since:
                older = 0
                yield row
            else:
                older += 1
                if older > 300:  # small safety margin; the file is sorted newest first
                    return

KEEP = ["NoticeId", "Title", "Type", "PostedDate", "ResponseDeadLine", "Department/Ind.Agency", "SetASideCode",
        "SetASide", "NaicsCode", "PopState", "Link"]   # contact name/email/phone columns are deliberately skipped
rows = [{k: r.get(k, "") for k in KEEP} for r in recent_opportunities()]
print(len(rows), "notices posted since", since)
print(Counter(r["SetASide"] or "(no set-aside)" for r in rows).most_common(12))
wosb = [r for r in rows if r["SetASideCode"] in ("WOSB", "WOSBSS", "EDWOSB", "EDWOSBSS")]
print(len(wosb), "WOSB/EDWOSB set-asides, e.g.:")
for r in wosb[:3]:
    print(" -", r["PostedDate"][:10], r["NaicsCode"], r["Title"][:70], r["Link"])

Because it streams and stops as soon as rows get older than the window, a 7-day pull reads only a small slice of the 200 MB file.

Three things that will trip you up

1. Encoding. The file is Windows-1252, not UTF-8. Read it as UTF-8 and you'll crash on the first curly quote. Use encoding="cp1252", errors="replace".
2. Huge text fields. Some description cells are bigger than Python's default CSV field limit, hence csv.field_size_limit(sys.maxsize).
3. Set-aside codes vs labels. Filter on SetASideCode, which is short and stable (SBA, SDVOSBC, HZC, 8A, WOSB, EDWOSB, plus sole-source codes like 8AN, WOSBSS and SDVOSBS). The SetASide label text changes wording over time.

Make it yours

• Add and r["NaicsCode"].startswith("2382") (or your NAICS codes) to the filter.
• Filter on PopState for place of performance near you.
• Run it every morning with cron or a scheduled GitHub Action, and email yourself the new rows (de-duplicate on NoticeId).
• The script leaves out the contact-person columns on purpose. Use the notice Link to reach the contracting office the official way.

Optional: I run this as a hosted, scheduled search with set-aside, NAICS and state filters: WOSB Federal Contracts (ready-made search) (paid per result). Disclosure: it's my tool. The script above does the same job for free.

In company-managed Jira Cloud you can't give Priority, Description, Labels or Assignee a default per work type. The request, JRACLOUD-4812, has about 2,800 votes. Team-managed projects have per-type defaults built in; company-managed projects don't. We built a small Forge app, Default Field Values for Jira, to close that gap. Here's how it works and what broke along the way.

UI modifications 101

Forge's jira:uiModifications module lets an app change fields inside Jira's Create dialog. You register a modification for a set of contexts (project + issue type), and Jira loads your resource when the dialog opens. In the onInit hook you read your stored config and call things like getFieldById('priority').setValue(...) or getFieldById('description').setValue(...). The user sees the values before clicking Create and can still change them.

Registering contexts when an admin saves

UI modifications only run where they're registered. So when an admin saves defaults for a project and issue type, the app's backend creates or updates the UI modification contexts via the REST API. If you forget this step, the dialog simply ignores you.

Why the dialog isn't enough

Board and backlog inline create never open the Create dialog, and neither do issues created through the REST API. For those, the app listens to the avi:jira:created:issue trigger and fills only the fields that are still empty, with notifications turned off. In our tests this usually applies within seconds, occasionally 1–2 minutes, because Forge triggers are asynchronous.

Bugs we hit

Priority wasn't applied to board-created issues. Jira always sets a priority, so the app only replaces it when the issue still has the default. We read "the default" from the global priority list's isDefault flag. On modern sites that's wrong: the priority scheme holds the default (defaultPriorityId). So our check never matched and the priority stayed Medium. The fix reads the default from GET /rest/api/3/priorityscheme?projectId=<id> and falls back to the global flag only when no scheme is returned.

The admin page needed two saves. Two causes. The form didn't reload from the stored config after saving, so it showed stale state. And the Assignee picker only took its value on first render, so later updates to it were ignored. Reloading the form from storage after each save, and making the picker follow its value, fixed it.

Limits to be honest about

• Fields can look empty for a split second before the defaults appear, because Jira loads app changes after the dialog opens.
• Jira allows up to 5 UI-modification apps per project and issue type.
• The Jira Service Management portal isn't supported.
• After-creation defaults aren't instant: usually within seconds, occasionally 1–2 minutes.

Disclosure: we're Loomwise and we built Default Field Values for Jira. It's free for up to 10 users and is in Atlassian Marketplace review now. Details: https://loomwise.app/jira-default-values/

When I ran the script below on Oct 23, 2026, the last 7 days returned 5,249 new New York LLCs and corporations and 1,100 new active Connecticut businesses. Connecticut's file also carries the NAICS industry code the owner picked at registration, so you can ask for "new construction companies" (95 that week) or "new restaurants" directly.

The sources

Both are Socrata portals, so they share one query language (SoQL) over plain HTTP.

The script

import requests, collections
from datetime import date, timedelta
since = (date.today() - timedelta(days=7)).isoformat()

# New York: Department of State "Active Corporations" (updated daily)
ny = requests.get("https://data.ny.gov/resource/n9v6-gdp6.json", params={
    "$select": "dos_id,current_entity_name,initial_dos_filing_date,county,entity_type",
    "$where": f"initial_dos_filing_date >= '{since}'",
    "$order": "initial_dos_filing_date DESC", "$limit": 50000}, timeout=60).json()
print("NY new entities:", len(ny))
print(collections.Counter(r.get("county") for r in ny).most_common(5))

# Connecticut: Secretary of the State Business Registry (updated daily, has NAICS)
ct = requests.get("https://data.ct.gov/resource/n7gp-d28j.json", params={
    "$select": "accountnumber,name,business_type,date_registration,naics_code,billingcity",
    "$where": f"date_registration >= '{since}' AND starts_with(status, 'Active')",
    "$order": "date_registration DESC", "$limit": 50000}, timeout=60).json()
print("CT new businesses:", len(ct))
sectors = collections.Counter((r.get("naics_code") or "(none)").rsplit("(", 1)[-1][:2] for r in ct)
print(sectors.most_common(6))
build = [r for r in ct if "(23" in (r.get("naics_code") or "")]
print("CT construction:", len(build), [r["name"] for r in build[:3]])

Output on Oct 23, 2026:

NY new entities: 5249
[('Kings', 754), ('Albany', 695), ('New York', 585), ('Queens', 550), ('Nassau', 487)]
CT new businesses: 1100
[('53', 173), ('54', 159), ('23', 95), ('45', 92), ('81', 85), ('56', 64)]
CT construction: 95 ['DD Ventures LLC', 'Elite Contracting LLC', 'Keystone Property Investments LLC']

In Connecticut, real estate (NAICS 53) and professional services (54) lead, with construction (23) close behind.

Gotchas I hit

1. Albany County is inflated in New York. Many filers list a registered-agent service in Albany, so "county" there often means the agent's county, not where the business operates. For local targeting, filter on ZIP (dos_process_zip) or on the location_* fields when they're filled in.
2. Connecticut NAICS is one text field, e.g. "Coin-Operated Laundries and Drycleaners (812310)". Match the prefix with contains(naics_code, '(23') in SoQL, or parse the digits in Python.
3. Filter out rejected filings. Connecticut includes Rejected registrations. Use starts_with(status, 'Active').
4. Treat person-related fields carefully. New York has CEO and registered-agent name fields, and Connecticut has a business email field that is often a personal address. For B2B outreach I leave those out and keep to the company name, industry, city and ZIP.
5. Use $limit explicitly. Socrata returns 1,000 rows by default. For larger pulls, page with $offset.

Turning it into a lead list

Run it daily or weekly, write the rows to CSV, and de-duplicate on dos_id / accountnumber. If you sell to one industry, the Connecticut NAICS filter does most of the qualifying for you. For New York, keyword filters on the name (contains(lower(current_entity_name), 'construction')) work surprisingly well.

Optional: if you'd rather not maintain the script, I publish these as hosted, scheduled tools: New York New Business Filings and Connecticut New Business Leads (paid per result, with personal fields stripped). Disclosure: they're my tools. The code above does the same job for free.

• Colorado: the Secretary of State's business entity register on data.colorado.gov (every LLC, corporation and nonprofit, with its formation date).
• Texas: the Comptroller's active sales tax permit list on data.texas.gov. A new permit means a business that's about to start selling.

When I ran this on Oct 23, 2026, the last 7 days held 3,588 new Colorado companies (Denver 963, Colorado Springs 440, Aurora 227) and 889 new Texas sales tax outlets (Houston 76, Austin 62, San Antonio 40).

The script

import requests
from collections import Counter
from datetime import date, timedelta

def colorado_new_companies(days=7, city=None):
    since = (date.today() - timedelta(days=days)).isoformat()
    where = f"entityformdate >= '{since}T00:00:00' AND entitytype in ('DLLC','DPC','DNC')"
    if city:
        where += f" AND upper(principalcity) = '{city.upper()}'"
    return requests.get("https://data.colorado.gov/resource/4ykn-tg5h.json", params={
        "$select": "entityid,entityname,entitytype,entityformdate,principalcity,principalzipcode",
        "$where": where, "$order": "entityformdate DESC", "$limit": 50000}, timeout=120).json()

def texas_new_outlets(days=7, city=None):
    since = (date.today() - timedelta(days=days)).isoformat()
    where = f"outlet_permit_issue_date >= '{since}T00:00:00'"
    if city:
        where += f" AND upper(outlet_city) = '{city.upper()}'"
    return requests.get("https://data.texas.gov/resource/jrea-zgmq.json", params={
        "$select": "outlet_name,outlet_city,outlet_zip_code,outlet_naics_code,outlet_permit_issue_date",
        "$where": where, "$order": "outlet_permit_issue_date DESC", "$limit": 50000}, timeout=120).json()

co = colorado_new_companies(7)
tx = texas_new_outlets(7)
print(len(co), "new Colorado companies; top cities:", Counter(r.get("principalcity", "").title() for r in co).most_common(5))
print(len(tx), "new Texas outlets; top cities:", Counter(r.get("outlet_city", "").title() for r in tx).most_common(5))

Want just Denver? colorado_new_companies(7, city="Denver"). Just Austin? texas_new_outlets(7, city="Austin").

Things that will trip you up

1. Colorado entity types are codes. DLLC is a domestic LLC, DPC a domestic corporation, DNC a domestic nonprofit. Foreign entities (FLLC, FPC) are out-of-state companies registering to do business in Colorado. Add them if you sell to expanding companies.
2. Texas has an industry code. outlet_naics_code lets you target, for example, 722511 (full-service restaurants) or 4441* (building material dealers). Filter with starts_with(outlet_naics_code, '722') in the $where.
3. Skip personal names. Both datasets include sole proprietors and registered agents who are individuals. The script selects only business and outlet names. That's better for privacy, and the business is who you want to reach anyway.
4. Use the SoS link to verify. Each Colorado row has an entityid, and https://www.coloradosos.gov/biz/BusinessEntityDetail.do?masterFileId=<entityid> opens the official record.

Turning it into a weekly lead list

Run it every Monday with days=7, de-duplicate on entityid (Colorado) or outlet name plus ZIP (Texas), and push the rows into a sheet or your CRM. Pair it with a building permits feed if you sell to trades: a new business plus a tenant-improvement permit at the same address is a hot lead.

Optional: if you'd rather not maintain the script, I publish both as hosted, scheduled tools: Colorado New Business Filings and Texas New Business Leads (paid per result). Disclosure: they're my tools. The code above does the same job for free.

How the work categories are assigned

Cities don't share a permit taxonomy. Austin uses "Electrical Permit - Residential" and Columbus uses "1,2,3 Family MEP"; others only have free text. I map each permit to one category using keyword rules over the type, work class and description, in priority order:

const RULES = [
  ['Solar', /solar|photovoltaic|\bpv\b/i],
  ['Roofing', /re-?roof|roofing|\broof\b/i],
  ['Mechanical / HVAC', /hvac|mechanical|furnace|heat pump|air condition|boiler|duct/i],
  // ...electrical, plumbing, new construction, demolition, etc.
];
const category = (p) =>
  (RULES.find(([, re]) => re.test(`${p.type} ${p.workClass} ${p.description}`)) || ['Other'])[0];

Order matters: a "re-roof and add solar" permit is counted as solar. Expect some noise, so spot-check the descriptions.

Solar: 1,439 permits

Most active by permit count: SUNRUN INSTALLATION SERVICES INC (150), NYSS LLC (50), SUNRUN INC (35), CERTIFIED ELECTRIC LLC (30).

Roofing: 4,130 permits

Most active by permit count: NEWMAN ROOFING LLC (58), ABLE ROOFING LLC (44), Premier South LLC (43), WINDOW NATION LLC (39).

Mechanical / HVAC: 6,624 permits

Most active by permit count: JT MAGEN & COMPANY INC (56), AIRTRON INC (53), Texas Multifamily Solution, LLC (41), COLONIAL HEATING AND COOLING CO INC (38).

Reading the numbers

• Solar is concentrated among a few installers. Sunrun entities alone pulled about 185 permits in 30 days. For an installer, this is a picture of competitor share. For suppliers and financiers, it's a target list.
• Roofing is the most "lead-like" trade. It's high-volume and residential, and about half of the permits name the roofer. Columbus and Miami-Dade dominate this month.
• HVAC values are unreliable. Many HVAC permits are equipment swaps with no value or a token one, so filter on type and description rather than value.

A practical workflow

1. Pick your trade and metros, then pull the last 30 days.
2. Selling to homeowners? A permit usually means that job is already sold. Use it for neighborhood marketing or for the follow-on trade (new roof, then solar, gutters or insulation).
3. Selling to contractors? Group by contractor name and rank by permit count to get a list of active installers.
4. Re-run weekly and keep only new permit numbers.

Get the data

Everything above came from the Building Permits Scraper. It has a workCategories filter (e.g. ["Solar","Roofing"]) plus states/regions filters, and costs $2 per 1,000 permits. Every source is an official open-data portal, linked in the README if you'd rather query it directly.

Related: Turning contractor registrations and building permits into a sales pipeline · Texas building permit leads: 10,910 permits from Austin, San Antonio, Collin County and more

Run on Oct 22, 2026, the script found:

• Oregon: 495 new contractor businesses in 30 days. 275 were residential general contractors, 67 lead-safe renovators and 53 residential specialty contractors. The top counties were Multnomah (62), Washington (56), Marion (48) and Clackamas (40), and 84 were out-of-state firms entering Oregon.
• Connecticut: 285 new contractor business licenses. 237 were home improvement contractors, 28 new home construction contractors, 15 major contractors and 3 demolition contractors.

The data sources

Both run on Socrata, so you query them with plain HTTP and SoQL.

The script

import requests, re
from datetime import date, timedelta
ENTITY = re.compile(r"\b(LLC|L\.L\.C\.|INC|CORP|CORPORATION|CO|COMPANY|LTD|LLP|LP|PLLC|PC)\b\.?", re.I)

def ct_new_contractors(days=30):
    since = (date.today() - timedelta(days=days)).isoformat()
    rows = requests.get("https://data.ct.gov/resource/ngch-56tr.json", params={
        "$select": "businessname,name,type,credential,fullcredentialcode,status,issuedate,city,zip",
        "$where": (f"issuedate >= '{since}' AND issuedate <= '{date.today()}T23:59:59' "
                   "AND upper(credential) like '%CONTRACTOR%' "
                   "AND type in ('LIMITED LIABILITY COMPANY','CORPORATION','BUSINESS','PARTNERSHIP')"),
        "$order": "issuedate DESC", "$limit": 5000}, timeout=120).json()
    return rows

def or_new_contractors(days=30):
    since = date.today() - timedelta(days=days)
    rows = requests.get("https://data.oregon.gov/resource/g77e-6bhs.json", params={
        "$select": "license_number,license_type,endorsement_text,full_name,city,county_name,orig_regis_date,ins_company,ins_exp_date",
        "$where": f"orig_regis_date like '%/{since.year}'", "$limit": 50000}, timeout=120).json()
    out = []
    for r in rows:
        m, d, y = map(int, r["orig_regis_date"].split("/"))
        if date(y, m, d) >= since and ENTITY.search(r.get("full_name", "")):
            out.append(r)
    return sorted(out, key=lambda r: r["orig_regis_date"][-4:] + r["orig_regis_date"][:5], reverse=True)

ct, orr = ct_new_contractors(), or_new_contractors()
print(len(ct), "new CT contractor businesses;", len(orr), "new OR contractor businesses")

Three things that will trip you up

1. Oregon stores dates as MM/DD/YYYY text. You can't run a date range query on the server. The script narrows by year with like '%/2026', then filters the exact window in Python. (For windows that cross New Year, add the previous year too.)
2. Connecticut has some future issue dates (data-entry errors such as 2027-03-31). Add an upper bound of today, as the script does.
3. Keep it to businesses. Both datasets include sole proprietors, whose names are personal names. Connecticut has a type column, so filter to LLCs, corporations and partnerships. Oregon doesn't, so keep only names with an entity marker (LLC, Inc, Corp...) and never pull the responsible-individual column. That's better for privacy, and businesses are the leads you want anyway.

Turning it into a weekly lead list

• Run it weekly with days=7, de-duplicate on license number, and append to a sheet or your CRM.
• Oregon's ins_company and ins_exp_date are useful for insurance agents: sort by expiration date for renewal timing.
• In Connecticut, change the credential filter to '%LIQUOR%' or '%FOOD%' and the same script finds new restaurants and bars.

Optional: if you'd rather not maintain the script, I publish both as hosted, scheduled tools: Oregon CCB Contractor License Scraper and Connecticut License Lookup (paid per result). Disclosure: they're my tools. The code above does the same job for free.

Originally published on dev.to.

This guide gives you a working Python function for each platform, the paging and date quirks that break naive scripts, and a way to merge cities into one table. Every snippet below was tested on Oct 22, 2026 against Chicago (Socrata), Louisville (ArcGIS) and Pittsburgh (CKAN). Together they returned 5,165 permits issued in the last 30 days, 756 of them worth $100k or more.

How to tell which platform a city uses

To find a city's feed, search catalog.data.gov, hub.arcgis.com, or " open data building permits."

The three fetchers

import requests
from datetime import date, datetime, timedelta, timezone
SINCE = date.today() - timedelta(days=30)

def socrata(domain, dataset, date_field, limit=1000):
    url = f"https://{domain}/resource/{dataset}.json"
    out, offset = [], 0
    while True:
        page = requests.get(url, params={
            "$where": f"{date_field} >= '{SINCE}T00:00:00'",
            "$order": f"{date_field} DESC, :id",   # stable order for paging
            "$limit": limit, "$offset": offset}, timeout=120).json()
        out += page
        if len(page) < limit: return out
        offset += limit

def arcgis(layer, date_field, page_size=1000):
    out, offset = [], 0
    while True:
        r = requests.get(layer + "/query", params={
            "where": f"{date_field} >= DATE '{SINCE}'", "outFields": "*", "f": "json",
            "orderByFields": f"{date_field} DESC", "resultOffset": offset,
            "resultRecordCount": page_size}, timeout=120).json()
        feats = [f["attributes"] for f in r.get("features", [])]
        for a in feats:  # ArcGIS dates are epoch milliseconds
            if isinstance(a.get(date_field), (int, float)):
                a[date_field] = datetime.fromtimestamp(a[date_field] / 1000, timezone.utc).date().isoformat()
        out += feats
        if not r.get("exceededTransferLimit"): return out
        offset += len(feats)

def ckan(domain, resource_id, date_field, limit=5000):
    sql = (f'SELECT * FROM "{resource_id}" WHERE "{date_field}" >= \'{SINCE}\' '
           f'ORDER BY "{date_field}" DESC LIMIT {limit}')
    r = requests.get(f"https://{domain}/api/3/action/datastore_search_sql", params={"sql": sql}, timeout=120).json()
    return r["result"]["records"]

The gotchas these functions handle

1. Socrata paging needs a stable order. If you page with $offset but sort only by date, rows that share a timestamp can repeat or go missing between pages. Adding :id as a tie-breaker fixes it.
2. Socrata leaves null fields out of the JSON. Rows come back with different keys. Use .get() everywhere, or call the .csv endpoint if you need fixed columns.
3. ArcGIS dates are epoch milliseconds, and the where clause needs DATE 'YYYY-MM-DD' syntax. A plain string comparison silently returns nothing on many servers.
4. ArcGIS caps each page (often at 1,000 or 2,000 rows) and tells you there's more with exceededTransferLimit. Loop until it's false.
5. CKAN column names are case-sensitive and often contain spaces (San Antonio uses "DATE ISSUED"), so always double-quote them in SQL.
6. Text-typed numbers. Many portals store valuation as text. Cast before you sum: float(x or 0) in Python, or ::number in SoQL.

Use it: three cities, one table

chicago = socrata("data.cityofchicago.org", "ydr8-5enu", "issue_date")
louisville = arcgis("https://services1.arcgis.com/79kfd2K6fskCAkyg/arcgis/rest/services/"
                    "active_construction_permits/FeatureServer/0", "ISSUE_DATE")
pittsburgh = ckan("data.wprdc.org", "f4d1177a-f597-4c32-8cbf-7885f56253f6", "issue_date")

def norm(city, r, num, date_f, desc, value, addr, contractor=None):
    return {"city": city, "permit": r.get(num), "issued": str(r.get(date_f))[:10],
            "description": r.get(desc), "value": float(r.get(value) or 0),
            "address": r.get(addr), "contractor": (r.get(contractor) or "").strip() or None}

rows = ([norm("Chicago", r, "permit_", "issue_date", "work_description", "reported_cost", "street_name") for r in chicago]
      + [norm("Louisville", r, "PERMIT_NUMBER", "ISSUE_DATE", "WORK_TYPE", "PROJECT_COSTS", "ADDRESS", "CONTRACTOR") for r in louisville]
      + [norm("Pittsburgh", r, "permit_id", "issue_date", "work_description", "total_project_value", "address", "contractor_name") for r in pittsburgh])
rows.sort(key=lambda r: r["issued"], reverse=True)
big = [r for r in rows if r["value"] >= 100_000]
print(len(rows), "permits,", len(big), "over $100k")

From here it's normal pandas: group by ZIP, filter descriptions for solar|roof|hvac|pool|adu, or write it all to a CSV.

Making it work for more cities

• Keep a config, not code. Store each city as (platform, endpoint, date field, field map) in a list. Adding a city then takes one line.
• Normalize work types yourself. Each city words them differently ("RES-ELC", "Electrical", "E-Permit"), so map them to your own categories with keyword rules.
• Watch for stale feeds. Some portals quietly stop updating. Log the newest issued date per city on every run and alert when it's more than about 14 days old.
• Respect the portals. Use their documented APIs, page politely, and cache. Socrata gives higher rate limits if you register a free app token.

Optional, and the code above is all you need: I maintain a hosted version of this pattern covering 47 cities and counties in one schema, Building Permits Scraper on Apify (paid per result). Disclosure: it's my tool.

Originally published on dev.to.

• An avi:jira:commented:issue trigger fires on every new comment.
• If the comment has no visibility set, the app calls the comment update API with the project's configured role/group.
• Per-project settings live in Forge storage, edited from an admin page; an issue panel shows status.
• No egress, so it qualifies as "Runs on Atlassian".

Trade-off: there's a short window between posting and restriction, the same as any non-browser-extension approach. Comments that already have a visibility are left alone.

Comments from Jira's native comment box are restricted automatically, usually within a minute.

Free install and setup guide: https://loomwise.app/jira-private-comments

Questions: hello@loomwise.app