# University of Utah TLO Available Technologies Scraper (`tehsnarf/utah-tlo-available-technologies`) Actor

Scrapes the University of Utah Technology Licensing Office's public Available Technologies catalog — docket ID, category, inventors, full description, and licensing contact info per listing.

- **URL**: https://apify.com/tehsnarf/utah-tlo-available-technologies.md
- **Developed by:** [Chris Hoover](https://apify.com/tehsnarf) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### What does University of Utah TLO Available Technologies Scraper do?

This Actor scrapes the **University of Utah Technology Licensing Office's** public
[Available Technologies](https://technologylicensing.utah.edu/available-technologies) catalog —
every licensable technology the university has disclosed for commercialization, including its
docket ID, category, inventors, full technical description, and licensing contact info. Give it a
listing URL, and it discovers every technology detail page (following pagination automatically) and
extracts a clean, structured record from each one. Runs on Apify with full API access, scheduling,
and integration support — no proxy or browser needed, since the source site is static HTML.

### Why use this Actor?

University tech-transfer offices publish some of the earliest, least-competed licensable IP on the
market — long before it shows up in patent databases or news coverage. This dataset is useful for:

- **Technology scouts and patent brokers** building a pipeline of licensable academic IP
- **Corporate R\&D teams** monitoring university research in a specific field for partnership or
  licensing opportunities
- **VCs and startup studios** looking for spin-out-ready technology before it's publicly hyped

### How to use University of Utah TLO Available Technologies Scraper

1. Click **Try for free** (or **Start**) on the Actor page
2. Leave the default **Start URL** (the full Available Technologies listing) or paste a specific
   listing URL, e.g. filtered by category
3. Set **Max items** to how many technologies you want (the Actor stops automatically once it hits
   this number, or your run's charge limit)
4. Click **Start** and download the results as JSON, CSV, Excel, or HTML once the run finishes

### Input

| Field | Type | Description |
|---|---|---|
| `startUrls` | array | Listing page URL(s) to crawl — default is the full Available Technologies index |
| `maxItems` | integer | Maximum technologies to scrape (default 100) |
| `delaySeconds` | number | Polite delay before each request (default 1.0s) |
| `concurrency` | integer | Parallel detail-page fetches (default 5) |

### Output

```json
{
  "technologyId": "U-8172",
  "technologyTitle": "A 3d Automated System For Accessible And Cost-effective Manufacturing With Generic Device Language And Fluid Simulation",
  "category": "Mechanical, Civil, & Environmental",
  "subcategory": null,
  "inventors": ["Bruce Gale", "BRADY GOENNER", "PIERRE-EMMANUEL GAILLARDON", "Greg Nordin"],
  "inventorLinks": ["https://www.mech.utah.edu/directory/faculty/bruce-gale/"],
  "briefSummary": "Innovative 3D system streamlines manufacturing, offering accessibility and cost-effectiveness through a generic device language and fluid simulation for design.",
  "problemStatement": "The emerging technology of microfluidic devices...",
  "technologyDescription": "A 3D automated microfluidic design system, adapted from mature electronic design tools...",
  "benefit": "o Simplifies the microfluidic design process for non-specialists. o Combines design, simulation, prototyping...",
  "contactName": "Jonathan Tyler",
  "contactEmail": "jonathan.tyler@utah.edu",
  "contactPhone": "801-587-0515",
  "detailUrl": "https://technologylicensing.utah.edu/available-technologies/U-8172"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data table

| Field | Description |
|---|---|
| `technologyId` | Docket ID (e.g. "U-8172") |
| `technologyTitle` | Technology title |
| `category` / `subcategory` | Classification tags |
| `inventors` / `inventorLinks` | Inventor names and faculty profile links, where available |
| `briefSummary` | Short summary, where available |
| `problemStatement` | Problem the technology addresses, where available |
| `technologyDescription` | Full technical description, where available |
| `benefit` | Listed benefits/advantages, where available |
| `contactName` / `contactEmail` / `contactPhone` | Licensing contact info |
| `detailUrl` | Canonical detail page URL |

Not every listing has every field — the TLO uses a few different page layouts (e.g. some show
"Stage of Development"/"IP" instead of "Brief Summary"/"Problem Statement"), so some fields will be
`null` where the source page doesn't have that section.

### How much does it cost to scrape University of Utah TLO's Available Technologies?

This Actor is billed **pay-per-result** at **$3 per 1,000 technologies scraped**. Since the source
is static HTML (no proxy or browser rendering required), runs are fast and cheap to operate:

| Results | Estimated cost |
|---|---|
| 100 | $0.30 |
| 500 | $1.50 |
| 1,000 | $3.00 |
| 5,000 | $15.00 |

### Tips

- Leave `maxItems` at a reasonable size for your use case — the full catalog is a few hundred
  technologies, so `maxItems: 500` comfortably covers everything currently listed.
- Increase `concurrency` (up to 20) for faster runs if you're scraping the full catalog; the built-in
  `delaySeconds` per-request delay is preserved regardless, so this only affects how many requests
  run in parallel, not how politely each one is spaced.

### FAQ, disclaimers, and support

This Actor only scrapes publicly published data (`robots.txt` places no restriction on this content)
with no login or PII involved — inventor names are already published by the university on public
faculty profile pages. Have a feature request or found a page layout it doesn't handle? Open an
issue on the Actor's Issues tab.

# Actor input Schema

## `startUrls` (type: `array`):

Listing page URL(s) to crawl — the actor discovers technology detail pages and follows pagination automatically.

## `maxItems` (type: `integer`):

Maximum number of technologies to scrape

## `delaySeconds` (type: `number`):

Polite delay each fetch waits before requesting

## `concurrency` (type: `integer`):

How many detail pages to fetch at once (each still waits delaySeconds before requesting)

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://technologylicensing.utah.edu/available-technologies"
    }
  ],
  "maxItems": 100,
  "delaySeconds": 1,
  "concurrency": 5
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("tehsnarf/utah-tlo-available-technologies").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("tehsnarf/utah-tlo-available-technologies").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call tehsnarf/utah-tlo-available-technologies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tehsnarf/utah-tlo-available-technologies"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/q5elEaIedgVuNLci9/builds/xfE4CpzmSMg5hcWr0/openapi.json