# FCC Accredited Test Labs Directory (`hgservices/fcc-accredited-test-labs`) Actor

Search FCC, CE, and internationally accredited compliance testing laboratories worldwide. Filter by country, accreditation status, test standards, and industries served.

- **URL**: https://apify.com/hgservices/fcc-accredited-test-labs.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Categories:** Automation, Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### What does FCC Accredited Test Labs Directory do?

**FCC Accredited Test Labs Directory** provides instant access to **591+ FCC, CE, and internationally accredited compliance testing laboratories** across **29 countries**. Whether you need EMC pre-compliance testing before submitting to an FCC-recognized lab, are searching for a partner to handle FCC Part 15 or CISPR 32 certification, or need a laboratory qualified for automotive, medical, IoT, or telecommunications standards — this Actor helps you find the right lab in seconds.

Every lab record includes its **accreditation designation**, **location**, **test standards** supported, **industries served**, and a **direct link** to verify capabilities. You can filter by country, accreditation status, test standards, and industries, then download the results as JSON, CSV, Excel, or HTML for use in your compliance workflows, vendor evaluations, or RFP processes.

Since this Actor runs on the **Apify platform**, you benefit from on-demand access, no infrastructure to manage, API integration with Zapier/Make/n8n for automated compliance workflows, and the ability to schedule regular exports to keep your vendor database up to date.

### Why use FCC Accredited Test Labs Directory?

- **Vendor qualification** — Shortlist labs by geographic region, test standards, and industry expertise before sending RFQs.
- **Compliance planning** — Find labs that support the exact standards you need (FCC Part 15, CISPR 32, EN 55032, IEC 62368-1, and 200+ more).
- **Supply chain diversification** — Identify alternative labs in different regions to reduce single-location dependency.
- **Market research** — Understand the competitive landscape of accredited testing laboratories worldwide.
- **Equipment certification** — Locate the nearest qualified lab for your product's required testing regime.

### How to use FCC Accredited Test Labs Directory

1. Open the Actor and go to the **Input** tab.
2. Set your filters — pick countries, accreditation status, test standards, industries, or enter a free-text search query. If you leave everything blank, you'll get all **Active** laboratories worldwide.
3. Click **Start**. The Actor processes your filters and returns matching laboratories in seconds.
4. Switch to the **Output** tab to view the results in a sortable table. Download them in JSON, CSV, Excel, or HTML format.

### Input

The Actor accepts the following input fields, all optional:

| Field | Type | Description |
|---|---|---|
| **Countries** | Multi-select dropdown | Limit results to specific countries (29 options). |
| **Accreditation Status** | Multi-select dropdown | Choose Active, Unknown, and/or Expired. **Defaults to Active** so you only see currently accredited labs. |
| **Test Standards** | String array | Filter labs by standards they support. Matching is **case-insensitive substring** — enter "CISPR" to find labs that test any CISPR standard (CISPR 32, CISPR 25, CISPR 11, etc.). |
| **Industries Served** | String array | Filter by industries (e.g., "automotive", "IoT", "medical", "consumer electronics"). Case-insensitive substring matching. |
| **Search Query** | Free text | Search across lab name, city, and description. |
| **Maximum Results** | Integer | Cap the number of results. Set to 0 for unlimited (default). |

Example input with all filters set to demonstrate a focused search:

```json
{
    "countries": ["United States", "Canada"],
    "accreditationStatus": ["Active"],
    "standards": ["FCC Part 15", "CISPR 32"],
    "industries": ["automotive"],
    "searchQuery": "Michigan",
    "maxResults": 50
}
````

### Output

The Actor outputs matching laboratories to the default dataset. Each result contains the full lab record:

```json
{
    "name": "Example Compliance Lab",
    "designation": "US1234",
    "location_text": "Detroit, Michigan, United States",
    "country": "United States",
    "state_province": "Michigan",
    "city": "Detroit",
    "accreditation_status": "Active",
    "description": "Full-service EMC and wireless testing laboratory...",
    "facility": "EMC, RF/wireless, and product safety testing laboratory",
    "badges": ["Active Accreditation", "★4.5(23 reviews)"],
    "standards_tested": ["FCC Part 15", "CISPR 32", "CISPR 25"],
    "industries_served": ["Automotive", "Wireless and IoT", "Connected devices"]
}
```

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

### Data table

The Output tab in Apify Console displays results in a table with these columns:

| Column | Description |
|---|---|
| **Name** | Laboratory name |
| **Location** | City, state/province, country |
| **Designation** | FCC or international accreditation designation code |
| **Status** | Accreditation status (Active, Unknown, Expired) |
| **Standards** | List of test standards supported by the lab |
| **Industries** | Industries the lab serves |

### Pricing / Cost estimation

How much does it cost to use this Actor? This Actor processes a curated directory — it does not make external web requests or use proxies. A typical run completes in **under 10 seconds** and costs a **fraction of a compute unit**. On the Apify Free plan you get $5/month in platform credits, which covers hundreds of runs. For paid plans, the cost per run is negligible.

### Tips

- **Leave filters empty** to export the entire database of Active labs for offline analysis.
- Use **Test Standards** and **Industries Served** together to find specialized labs — for example, labs that test both MIL-STD-461 (military EMC) and serve the aerospace industry.
- The **Search Query** field searches across lab name, city, and description simultaneously — great for finding labs in a specific city or with a particular capability.
- For recurring exports, **schedule** the Actor to run daily or weekly and send results to your email or Google Sheets via Apify integrations.
- Download results as **CSV** and import directly into Excel or Google Sheets for further filtering and analysis.

### FAQ, disclaimers, and support

**Where does the data come from?** The Actor compiles laboratory records from publicly available accreditation databases, laboratory filings, and provider profiles to create a comprehensive, searchable directory. Data is refreshed periodically to reflect accreditation status changes.

**How current is the accreditation data?** Lab records include their accreditation status (Active, Unknown, Expired). Always verify the current status directly with the laboratory before engaging their services, as accreditation statuses can change.

**What if a lab I need isn't listed?** The directory covers 591+ labs but may not include every accredited facility. If you notice gaps, report them via the Issues tab on the Actor's page.

**Is this legal to use?** Yes. The directory aggregates publicly available information about accredited testing laboratories. It does not scrape protected content or bypass access controls.

**Need a custom solution?** If you need a tailored version of this Actor — custom filters, different output formats, integration with your internal systems, or additional data fields — contact the developer through the Issues tab or explore Apify's [custom Actor development](https://apify.com/custom-solutions).

For bugs, feature requests, or feedback, use the **Issues** tab on this Actor's page.

# Actor input Schema

## `countries` (type: `array`):

Filter laboratories by country. Leave empty to include all countries.

## `accreditationStatus` (type: `array`):

Filter by accreditation status. Defaults to Active only so expired and unknown-status labs are excluded unless you specifically request them.

## `standards` (type: `array`):

Filter by test standards the lab supports. Enter one or more standards (e.g. FCC Part 15, CISPR 32, IEC 62368-1). Matching is case-insensitive substring — entering 'CISPR' will match CISPR 32, CISPR 25, CISPR 11, etc.

## `industries` (type: `array`):

Filter by industries the lab serves (e.g. automotive, IoT, medical, consumer electronics). Matching is case-insensitive substring.

## `searchQuery` (type: `string`):

Search across laboratory name, city, and description. Matching is case-insensitive substring.

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

Maximum number of results to return. Set to 0 for unlimited results.

## Actor input object example

```json
{
  "accreditationStatus": [
    "Active"
  ],
  "maxResults": 0
}
```

# 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 = {
    "accreditationStatus": [
        "Active"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/fcc-accredited-test-labs").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 = { "accreditationStatus": ["Active"] }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/fcc-accredited-test-labs").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 '{
  "accreditationStatus": [
    "Active"
  ]
}' |
apify call hgservices/fcc-accredited-test-labs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=hgservices/fcc-accredited-test-labs",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FCC Accredited Test Labs Directory",
        "description": "Search FCC, CE, and internationally accredited compliance testing laboratories worldwide. Filter by country, accreditation status, test standards, and industries served.",
        "version": "1.0",
        "x-build-id": "5oLpylneDw2PK099N"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hgservices~fcc-accredited-test-labs/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hgservices-fcc-accredited-test-labs",
                "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/hgservices~fcc-accredited-test-labs/runs": {
            "post": {
                "operationId": "runs-sync-hgservices-fcc-accredited-test-labs",
                "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/hgservices~fcc-accredited-test-labs/run-sync": {
            "post": {
                "operationId": "run-sync-hgservices-fcc-accredited-test-labs",
                "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": {
                    "countries": {
                        "title": "Countries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter laboratories by country. Leave empty to include all countries.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "United States",
                                "China",
                                "Taiwan",
                                "Japan",
                                "South Korea",
                                "Germany",
                                "United Kingdom",
                                "Canada",
                                "Italy",
                                "Hong Kong",
                                "France",
                                "Netherlands",
                                "Israel",
                                "Australia",
                                "Sweden",
                                "India",
                                "Finland",
                                "Malaysia",
                                "Denmark",
                                "New Zealand",
                                "Singapore",
                                "Austria",
                                "Belgium",
                                "Spain",
                                "Ireland",
                                "Norway",
                                "Philippines",
                                "Slovenia",
                                "Switzerland"
                            ],
                            "enumTitles": [
                                "United States",
                                "China",
                                "Taiwan",
                                "Japan",
                                "South Korea",
                                "Germany",
                                "United Kingdom",
                                "Canada",
                                "Italy",
                                "Hong Kong",
                                "France",
                                "Netherlands",
                                "Israel",
                                "Australia",
                                "Sweden",
                                "India",
                                "Finland",
                                "Malaysia",
                                "Denmark",
                                "New Zealand",
                                "Singapore",
                                "Austria",
                                "Belgium",
                                "Spain",
                                "Ireland",
                                "Norway",
                                "Philippines",
                                "Slovenia",
                                "Switzerland"
                            ]
                        }
                    },
                    "accreditationStatus": {
                        "title": "Accreditation Status",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by accreditation status. Defaults to Active only so expired and unknown-status labs are excluded unless you specifically request them.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Active",
                                "Unknown",
                                "Expired"
                            ],
                            "enumTitles": [
                                "Active",
                                "Unknown",
                                "Expired"
                            ]
                        },
                        "default": [
                            "Active"
                        ]
                    },
                    "standards": {
                        "title": "Test Standards",
                        "type": "array",
                        "description": "Filter by test standards the lab supports. Enter one or more standards (e.g. FCC Part 15, CISPR 32, IEC 62368-1). Matching is case-insensitive substring — entering 'CISPR' will match CISPR 32, CISPR 25, CISPR 11, etc.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "industries": {
                        "title": "Industries Served",
                        "type": "array",
                        "description": "Filter by industries the lab serves (e.g. automotive, IoT, medical, consumer electronics). Matching is case-insensitive substring.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search across laboratory name, city, and description. Matching is case-insensitive substring."
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of results to return. Set to 0 for unlimited results.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
