# US Congress Member Finder | Profiles & Social Media (`arjun_code/us-congress-member-finder`) Actor

Find current or former US members of Congress by name or Bioguide ID. Get verified profiles, terms, party, state, office contacts, official websites and official social media accounts in structured JSON, CSV or Excel.

- **URL**: https://apify.com/arjun\_code/us-congress-member-finder.md
- **Developed by:** [Arjun AI](https://apify.com/arjun_code) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 congress member profiles

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

Find current and former United States senators and representatives by name or official Bioguide ID. **US Congress Member Finder** returns verified profiles, congressional service history, party information, office contacts, official websites, and known official social media accounts.

Enter one name, a list of names, exact Bioguide IDs, or both. Only verified congressional members are saved to the Dataset, ready to download as JSON, CSV, or Excel.

### What can US Congress Member Finder do?

- Find current and former members of the US House and Senate.
- Resolve a person's name to a stable Bioguide ID.
- Return chamber, state, district, party, and congressional terms.
- Collect Washington office addresses, phone numbers, and official websites when available.
- Find known official Twitter/X, Facebook, Instagram, YouTube, and Mastodon accounts.
- Return sponsored and cosponsored legislation counts.
- Deduplicate members found through both name search and exact ID lookup.
- Run manually, on a schedule, through the Apify API, or from an automation workflow.

Common uses include building a Congress directory, enriching civic or government-relations data, supporting journalism and policy research, and connecting CRM records to official congressional profiles.

### How to find a Congress member

1. Open the Actor's **Input** tab.
2. Add one or more names under **Member names**, or enter exact IDs under **Bioguide IDs**.
3. Keep **Maximum search results per name** at `10` unless a common or ambiguous name needs a wider search.
4. Select **Start** and wait for the run to finish.
5. Open **Verified member profiles** to review or export the results.

Name search and Bioguide ID lookup can be used in the same run. If both inputs resolve to the same person, the member is returned once and both match methods are recorded.

#### Search by member name

```json
{
  "queries": ["Todd Young", "Alexandria Ocasio-Cortez"],
  "bioguideIds": [],
  "maxSearchResults": 10
}
```

#### Look up an exact Bioguide ID

```json
{
  "queries": [],
  "bioguideIds": ["Y000064"],
  "maxSearchResults": 10
}
```

### Input parameters

| Field | Required | Description |
| --- | --- | --- |
| `queries` | One input method required | Names to search. Whitespace is removed and duplicate names are processed once. An ambiguous name can produce more than one verified member. |
| `bioguideIds` | One input method required | Exact official Bioguide IDs such as `Y000064`. Use these when you already know the member identifier. |
| `maxSearchResults` | No | Candidate records examined per name. Default: `10`. Range: `1` to `30`. Higher values can help with ambiguous names but may take longer. |

Provide at least one non-empty value in `queries` or `bioguideIds`. Current and former members are included automatically; no separate mode is required.

### US Congress member data returned

Each Dataset item represents one verified member and can include:

| Data group | Example fields |
| --- | --- |
| Identity | `name`, `bioguideId`, `birthYear`, `previousNames` |
| Current role | `currentMember`, `chamber`, `memberType`, `state`, `district` |
| Service history | `currentTerm`, `terms`, `party`, `partyHistory` |
| Contact details | `officialWebsite`, `officeAddress`, `officePhone` |
| Legislation | `sponsoredLegislationCount`, `cosponsoredLegislationCount` |
| Social media | `twitterUrl`, `facebookUrl`, `instagramUrl`, `youtubeUrl`, `socialMedia` |
| Freshness | `profileUpdatedAt`, `checkedAt` |

#### Output example

```json
{
  "query": "Todd Young",
  "matchedQueries": ["Todd Young"],
  "matchedBy": ["nameSearch"],
  "matchStatus": "matched",
  "bioguideId": "Y000064",
  "name": "Todd Young",
  "birthYear": 1972,
  "currentMember": true,
  "chamber": "Senate",
  "memberType": "Senator",
  "state": "Indiana",
  "stateCode": "IN",
  "district": "",
  "party": "Republican",
  "partyCode": "R",
  "officialWebsite": "https://www.young.senate.gov",
  "officePhone": "(202) 224-5623",
  "twitterUrl": "https://twitter.com/SenToddYoung",
  "facebookUrl": "https://www.facebook.com/SenatorToddYoung",
  "instagramUrl": "https://www.instagram.com/sentoddyoung/",
  "youtubeUrl": "https://www.youtube.com/channel/UCuknj4PGn91gHDNAfboZEgQ"
}
```

Missing scalar values are returned as `""`; missing lists are returned as `[]`. Searches that do not resolve to a congressional member are recorded in the run summary rather than returned as misleading profile rows.

### How much does a Congress member lookup cost?

The Actor charges **$0.002 for each verified member profile saved to the Dataset**.

| Verified results | Price |
| ---: | ---: |
| 1 | $0.002 |
| 100 | $0.20 |
| 1,000 | $2.00 |

Unresolved names, filtered search candidates, and failed profile lookups are not charged. Current and former members use the same price.

### Run US Congress Member Finder with the API

Use the Actor ID with the Apify Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("FKMPAhb1n4Oar4V8i").call(run_input={
    "queries": ["Todd Young", "Bernie Sanders"],
    "bioguideIds": [],
    "maxSearchResults": 10,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

The Dataset can also be consumed through the Apify API, webhooks, scheduled runs, and integrations. This makes the Actor suitable for recurring directory updates and downstream data pipelines.

### Understanding the results

- `matchedBy: ["nameSearch"]` means the member was discovered from a supplied name.
- `matchedBy: ["bioguideId"]` means an exact identifier was supplied.
- If both methods resolve to one member, both values appear in `matchedBy` and only one item is returned.
- `currentTerm` is the most recent returned congressional term.
- `district` is normally empty for senators.
- Social fields contain known official legislative accounts. Campaign and personal accounts are not included.
- An empty social or contact field means no verified value was available; it does not prove that the account or contact method does not exist.
- Contact details and legislation counts can change. Use `profileUpdatedAt` and `checkedAt` to assess freshness.

### Frequently asked questions

#### Does this Actor include former members of Congress?

Yes. Current and former members are searched automatically. Check `currentMember` and `terms` to distinguish active service from historical service.

#### Why did a name return no Dataset item?

The search may not have resolved to a verified congressional Bioguide ID. Organizations, unrelated people, and unverified candidates are filtered out. Try the full name, increase `maxSearchResults`, or use an exact Bioguide ID.

#### Can one name return multiple members?

Yes. Common or ambiguous names can resolve to multiple verified congressional members. Every returned item includes its own Bioguide ID and service history.

#### Why is a social media or office field empty?

The current profile did not contain a verified value for that field. The Actor returns an empty string instead of guessing.

#### Can I automate recurring lookups?

Yes. Save the input as a Task, schedule it, connect a webhook, or call the Actor from your application through the Apify API.

### Support

If a verified member is missing or a field looks outdated, create an issue from the Actor page and include the member name or Bioguide ID plus the Apify run ID. Never include API tokens or other credentials in a public issue.

# Actor input Schema

## `queries` (type: `array`):

Names to search, such as Todd Young or Alexandria Ocasio-Cortez. A name can produce more than one verified member when the search is ambiguous. Leave empty when using Bioguide IDs only.

## `bioguideIds` (type: `array`):

Official congressional Bioguide IDs for exact lookup, for example Y000064. These entries bypass name search. Leave empty if you only know member names.

## `maxSearchResults` (type: `integer`):

Maximum number of search candidates examined for each name. Values above 10 use additional result pages. Organizations, unrelated people and records without a congressional identifier are filtered out.

## Actor input object example

```json
{
  "queries": [
    "Todd Young",
    "Bernie Sanders"
  ],
  "bioguideIds": [
    "Y000064"
  ],
  "maxSearchResults": 10
}
```

# Actor output Schema

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

One row per distinct verified member, including profile details, term history and available official social media accounts.

## `summary` (type: `string`):

Input, candidate, filtering, source availability, successful output and error counts for this run.

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

// Run the Actor and wait for it to finish
const run = await client.actor("arjun_code/us-congress-member-finder").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 = { "bioguideIds": ["Y000064"] }

# Run the Actor and wait for it to finish
run = client.actor("arjun_code/us-congress-member-finder").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 '{
  "bioguideIds": [
    "Y000064"
  ]
}' |
apify call arjun_code/us-congress-member-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arjun_code/us-congress-member-finder"
        }
    }
}
```

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/FKMPAhb1n4Oar4V8i/builds/4kxcfCZu4jDfRxcrH/openapi.json