# NOAA Fisheries Commercial Landings Scraper (`compute-edge/noaa-fisheries-landings-scraper`) Actor

Extract US commercial and recreational fish landings from the NOAA Fisheries FOSS public API. Filter by species, state, and year. Includes pounds, dollars, and metric tons.

- **URL**: https://apify.com/compute-edge/noaa-fisheries-landings-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## NOAA Fisheries Commercial & Recreational Landings Scraper

Extract structured **commercial and recreational fishing landings data** from the **NOAA Fisheries One Stop Shop (FOSS)** — the authoritative federal registry of U.S. fish and shellfish landings maintained by NOAA's National Marine Fisheries Service (NMFS). This Actor queries the public FOSS REST API and delivers clean, filterable results ready for market research, fisheries economics, and supply-chain analysis.

The FOSS database is the gold standard for U.S. fisheries data. It covers **all U.S. states and territories** (Gulf, Atlantic, Pacific, and Alaska regions), **hundreds of commercial and recreational species**, and **decades of historical records** back to the 1980s. Fields include species common and scientific names, state, NOAA region, year, **pounds landed**, and **ex-vessel dollar value** — the exact market-sizing signals that seafood processors, marine industry analysts, and fisheries economists need.

### Key Features

- **No API key required** — Pulls directly from the public NOAA FOSS ODS REST API
- **Commercial and recreational landings** — Separate tracking for commercial harvests and MRIP recreational survey data
- **Filter by state, species, year range, and collection type** — Focus on exactly the data you need
- **Historical depth** — Data back to the 1980s for long-term trend analysis
- **Clean JSON output** — Species name, scientific name, region, state, year, pounds, dollar value, and source type
- **Batch-optimized** — Streams results in batches of 500; controlled by configurable `maxResults`
- **LLM-ready output** — Structured fields designed for RAG pipelines, dashboards, and spreadsheet analysis

### Output Data Fields

| Field | Type | Description |
|-------|------|-------------|
| `speciesName` | string | AFS common name of the species (e.g., "SALMON, CHINOOK") |
| `scientificName` | string | Scientific name when available (e.g., "Oncorhynchus tshawytscha") |
| `region` | string | NOAA region (e.g., "Pacific", "Gulf", "New England") |
| `state` | string | U.S. state or territory name (e.g., "ALASKA", "MAINE") |
| `year` | integer | Reporting year |
| `collection` | string | "Commercial" for commercial fishing; "Recreational" for MRIP survey |
| `pounds` | integer | Total pounds landed (live weight equivalent) |
| `dollars` | integer | Ex-vessel value in USD (what the vessel was paid at the dock) |
| `totalCount` | integer | Estimated total count of fish for recreational catch data |
| `source` | string | Data source code (e.g., "MRIP", "ACCSP", "PacFIN") |

### How to Scrape NOAA Fisheries Landings Data

#### Step-by-Step Tutorial

1. Open the **NOAA Fisheries Landings Data Scraper** on Apify Store and click **Start**.
2. Set your **State Name** to focus on a specific state (e.g., `ALASKA`) or leave blank for all states.
3. Set a **Species Name** filter to narrow results (e.g., `SALMON` or `HALIBUT`) or leave blank for all species.
4. Set **Year From** and **Year To** to define your analysis window (e.g., 2018–2024 for recent trends).
5. Choose a **Collection Type**: `Commercial` for commercial harvest data, `Recreational` for MRIP survey data, or leave blank for both.
6. Set **Max Results** to control how many records are returned (default: 2000; set to 0 for unlimited).
7. Click **Start** and wait for the run to complete (typically 30–120 seconds for default queries).
8. Download results as **JSON, CSV, or Excel** from the Dataset tab.

#### Use Case Examples

**Market sizing for salmon supply chains:**
Set `speciesName=SALMON`, `collection=Commercial`, `yearFrom=2018`, `yearTo=2023`. Get pounds landed and ex-vessel value by state across all Pacific and Alaska regions — a comprehensive picture of U.S. salmon harvest volume trends over five years.

**Gulf shrimp industry analysis:**
Set `stateName=LOUISIANA`, `speciesName=SHRIMP`, `collection=Commercial`. Extract annual commercial shrimp landings from the Gulf's largest producing state, including dollar value time-series data for pricing and market share analysis.

**Recreational fishery health monitoring:**
Set `collection=Recreational`, `speciesName=TUNA`, `yearFrom=2015`, `yearTo=2024`. Track recreational tuna catch trends across all coastal states using MRIP survey data — useful for marine conservation NGOs and fishing industry associations.

### Input Example

```json
{
    "stateName": "ALASKA",
    "speciesName": "SALMON",
    "yearFrom": 2018,
    "yearTo": 2023,
    "collection": "Commercial",
    "maxResults": 1000
}
````

### Output Example

```json
{
    "speciesName": "SALMON, CHINOOK",
    "scientificName": "Oncorhynchus tshawytscha",
    "region": "Pacific",
    "state": "ALASKA",
    "year": 2022,
    "collection": "Commercial",
    "pounds": 12483521,
    "dollars": 47820330,
    "totalCount": null,
    "source": "PacFIN"
}
```

### Pricing

This Actor fetches data from a free, keyless public API with pagination.

- **Cost per result**: $0.003/result
- **Typical run** (2,000 records, default settings): ~$0.006 in Actor fees
- **Memory required**: 256–512 MB
- **Typical run time**: 30–120 seconds depending on result count and filters

All pricing is transparent and set before the Actor is public per Apify's standard.

### Who Uses This Data?

- **Seafood processors and distributors** — Monitor annual landings volume by species and state to forecast supply, negotiate contracts, and identify regional sourcing opportunities
- **Commercial fishing operators** — Benchmark catch performance and market share against statewide landing totals
- **Marine industry analysts and consultants** — Build fisheries market reports with decades of NOAA-verified volume and price data
- **Fisheries economists and researchers** — Time-series analysis of ex-vessel values, species mix trends, and regional production shifts
- **Environmental NGOs and conservation groups** — Monitor harvest trends relative to stock assessments and management targets
- **Government agencies and policy teams** — Assess commercial fishing industry health, inform quota decisions, and track MRIP recreational survey participation

### FAQ

#### Is it legal to scrape NOAA fisheries landings data?

Yes. This Actor accesses publicly available data from the NOAA Fisheries One Stop Shop (FOSS), a federally maintained open data platform. No authentication is required and no terms of service are bypassed. NOAA data is U.S. government public domain information.

#### Why does ex-vessel value (dollars) sometimes show null?

Not all species or collection types have dollar values reported. Recreational landings typically report pounds and estimated counts but not dollar values. Some commercial species in certain regions may also lack consistent dollar reporting in the FOSS system.

#### How far back does the data go?

Coverage varies by region and species, but the dataset includes records back to the 1980s for most major commercial species. Use `yearFrom=1980` and broad species/state filters to explore historical depth.

#### Can I export the data to Excel or CSV?

Yes. After a run completes, use the Dataset tab in Apify Console to download results in JSON, CSV, Excel, XML, or other formats.

#### Why does the Actor not filter server-side?

The NOAA FOSS ODS API does not support field-level server-side filtering — query parameters like `state_name=ALASKA` are present in the API URL but are not applied by the underlying database engine. This Actor handles all filtering client-side by fetching and scanning pages efficiently, stopping as soon as `maxResults` is satisfied.

#### How do I get data for all time without limits?

Set `maxResults=0` to disable the limit and retrieve all matching records. For broad queries (all states, all species, many years), this may take several minutes and return tens of thousands of records.

### Other Scrapers by SeatSignal

Explore more government and industrial data scrapers in the SeatSignal portfolio:

- [OSHA Inspections Scraper](https://apify.com/seatsignal/osha-inspections-scraper) — Workplace safety inspection records and violation data
- [EPA ECHO Scraper](https://apify.com/seatsignal/epa-echo-scraper) — Environmental compliance and enforcement data
- [CISA KEV Scraper](https://apify.com/seatsignal/cisa-kev-scraper) — CISA Known Exploited Vulnerabilities catalog
- [USDA NASS Agricultural Surveys Scraper](https://apify.com/seatsignal/usda-nass-scraper) — Crop production, livestock, and farm economics data

### Legal Disclaimer

This Actor extracts publicly available data from the NOAA Fisheries One Stop Shop (FOSS), a U.S. federal government open data platform. No authentication bypass, credential use, or terms-of-service violation is involved. Users are responsible for ensuring their use of the extracted data complies with applicable laws and regulations. For support, contact the Actor developer through Apify Store.

# Actor input Schema

## `stateName` (type: `string`):

Filter by U.S. state or territory name (case-insensitive partial match). Examples: 'ALASKA', 'MAINE', 'LOUISIANA', 'GULF'. Leave empty to include all states.

## `speciesName` (type: `string`):

Filter by common species name (case-insensitive partial match). Examples: 'SALMON', 'SHRIMP', 'CRAB', 'TUNA', 'HALIBUT'. Leave empty to include all species.

## `yearFrom` (type: `integer`):

Earliest year to include in results. Data goes back to the 1980s. Defaults to 5 years before yearTo.

## `yearTo` (type: `integer`):

Latest year to include in results. Defaults to the most recently completed year.

## `collection` (type: `string`):

Filter by collection type. 'Commercial' for commercial fishing landings, 'Recreational' for recreational fishing surveys (MRIP). Leave empty for both.

## `maxResults` (type: `integer`):

Maximum number of landing records to return. Set to 0 for unlimited (may be slow for broad queries).

## Actor input object example

```json
{
  "stateName": "",
  "speciesName": "",
  "yearFrom": 2019,
  "yearTo": 2024,
  "collection": "",
  "maxResults": 2000
}
```

# Actor output Schema

## `dataset` (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("compute-edge/noaa-fisheries-landings-scraper").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("compute-edge/noaa-fisheries-landings-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 compute-edge/noaa-fisheries-landings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=compute-edge/noaa-fisheries-landings-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NOAA Fisheries Commercial Landings Scraper",
        "description": "Extract US commercial and recreational fish landings from the NOAA Fisheries FOSS public API. Filter by species, state, and year. Includes pounds, dollars, and metric tons.",
        "version": "0.1",
        "x-build-id": "6cM6xQ0MCoYDySpSr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~noaa-fisheries-landings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-noaa-fisheries-landings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/compute-edge~noaa-fisheries-landings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-noaa-fisheries-landings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/compute-edge~noaa-fisheries-landings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-noaa-fisheries-landings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "stateName": {
                        "title": "State Name",
                        "type": "string",
                        "description": "Filter by U.S. state or territory name (case-insensitive partial match). Examples: 'ALASKA', 'MAINE', 'LOUISIANA', 'GULF'. Leave empty to include all states.",
                        "default": ""
                    },
                    "speciesName": {
                        "title": "Species Name",
                        "type": "string",
                        "description": "Filter by common species name (case-insensitive partial match). Examples: 'SALMON', 'SHRIMP', 'CRAB', 'TUNA', 'HALIBUT'. Leave empty to include all species.",
                        "default": ""
                    },
                    "yearFrom": {
                        "title": "Year From",
                        "type": "integer",
                        "description": "Earliest year to include in results. Data goes back to the 1980s. Defaults to 5 years before yearTo.",
                        "default": 2019
                    },
                    "yearTo": {
                        "title": "Year To",
                        "type": "integer",
                        "description": "Latest year to include in results. Defaults to the most recently completed year.",
                        "default": 2024
                    },
                    "collection": {
                        "title": "Collection Type",
                        "enum": [
                            "",
                            "Commercial",
                            "Recreational"
                        ],
                        "type": "string",
                        "description": "Filter by collection type. 'Commercial' for commercial fishing landings, 'Recreational' for recreational fishing surveys (MRIP). Leave empty for both.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Maximum number of landing records to return. Set to 0 for unlimited (may be slow for broad queries).",
                        "default": 2000
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
