# API Keys
Source: https://docs.getprofile-ai.com/api-keys
Manage secret keys for the GetProfile API
Your API key is the **gateway** to your app's profiling data and must be handled with care.
***
## What is an API Key?
Each app in GetProfile has a unique **API key** that:
* Authenticates your requests
* Enforces your usage quotas and plan limits
* Segregates your data from other apps
***
## Best Practices
* **Keep it secret!** Never share your API key publicly or commit it to version control.
* **Use environment variables** to store your API key securely in your applications.
* **Rotate keys** periodically for added security — you can do this from your dashboard.
Example for a secure environment variable in a `.env` file:
```plaintext theme={null}
GETPROFILE_API_KEY=your_api_key_here
```
Then, access it in your code:
In Python:
```python theme={null}
import os
api_key = os.getenv('GETPROFILE_API_KEY')
```
In Node.js:
```js theme={null}
const apiKey = process.env.GETPROFILE_API_KEY;
```
***
## Rotating or Revoking API Keys
* Go to your **API Keys** page in the dashboard.
* Use the **rotate** button to generate a new API key — the old one will stop working immediately.
* If you suspect your key has been exposed, **revoke** it right away.
***
## Where is the API Key used?
Your API key must be included in the `Authorization` header for every API request:
```http theme={null}
Authorization: Bearer YOUR_API_KEY
```
Example `curl` request:
```bash theme={null}
curl -X GET "https://api.getprofile-ai.com/v1/profile/abc123" \
-H "Authorization: Bearer YOUR_API_KEY"
```
***
## Lost your API key?
No worries! Just **rotate** it in the dashboard to generate a fresh one. Your existing integrations will need to be updated with the new key.
***
For any questions or concerns, contact our support team at [support@getprofile-ai.com](mailto:support@getprofile-ai.com).
Stay secure and keep building amazing experiences!
# Authentication
Source: https://docs.getprofile-ai.com/api-reference/authentication
All API requests to GetProfile require authentication using your **app's API key**.
## How it works
Each app in your account has a unique API key. This key identifies your app and ensures that only you can access and modify your data.
* **Keep your API key secure**
* **Rotate keys in your dashboard if needed**
* **Use different keys for different apps or environments**
***
## Adding the API key to requests
You must include your API key in the `Authorization` header of every request:
```http theme={null}
Authorization: Bearer YOUR_API_KEY
```
For example:
```bash theme={null}
curl -X GET "https://api.getprofile-ai.com/v1/profile/abc123" \
-H "Authorization: Bearer YOUR_API_KEY"
```
## Where to find your API key
1. Log in to your Dashboard.
2. Go to the API Keys page.
3. Copy the API key for the app you want to integrate.
If your API key is compromised, rotate it from the dashboard to protect your data.
## Tips for API key usage
* Never commit your API key to public repositories.
* Use environment variables (process.env.YOUR\_API\_KEY) in your backend for secure usage.
* Periodically review and rotate keys to maintain security.
For more details on secret keys see the [API Keys](/builders/api-keys) documentation.
# Introduction
Source: https://docs.getprofile-ai.com/api-reference/introduction
Welcome to the **GetProfile API Reference**. Here you’ll find detailed information on every endpoint, including request parameters, response formats, and examples.
Production API URL: `https://api.getprofile-ai.com`
Our API is designed to be:
* **RESTful**: Predictable endpoints and JSON responses.
* **Secure**: Authenticate using your secret API key.
* **Flexible**: Send any structured or unstructured data to build rich user profiles.
* **Asynchronous**: Profiling requests are accepted instantly and processed in the background.
Whether you’re integrating GetProfile with your app, chatbot, or game, this reference has everything you need to get started.
👉 Start with the **[Quickstart](/quickstart)** for a guided intro.
For usage quotas, authentication, and plan details, see the **[Dashboard](/dashboard)** section.
Let’s build smarter, more personalized experiences together!
# Delete Profile
Source: https://docs.getprofile-ai.com/api-reference/profile/delete
DELETE /v1/profile/{id}
Deletes a profile from the GetProfile API by its ID
# Get Profile
Source: https://docs.getprofile-ai.com/api-reference/profile/get
GET /v1/profile/{id}
Retrieve a raw profile data from the GetProfile API by its ID
# Update Profile
Source: https://docs.getprofile-ai.com/api-reference/profile/post
POST /v1/profile/{id}
Creates or updates a profile in the GetProfile API by its ID
# Search Profiles
Source: https://docs.getprofile-ai.com/api-reference/search/get
GET /v1/search
Search for profiles using semantic vector search and classic filtering, sorting, and pagination
# Get Profile
Source: https://docs.getprofile-ai.com/builders/get-profile
Get structured profiles from the GetProfile API
After submitting data, you can **retrieve the structured profile** for a given user, character, or entity:
```http theme={null}
GET /v1/profile/{profile_id}
```
Example:
```bash theme={null}
curl -X GET "https://api.getprofile-ai.com/v1/profile/abc123" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
```
***
## What’s in a Profile?
A profile contains structured information extracted from your data:
* **profile\_id**: Unique identifier for the profile.
* **summary**: AI-generated summary of the profile, useful for quick overviews or providing context to LLMs.
* **core\_info**: Basic info like name, age, gender, and location.
* **interests**: Categorized interests (music, hobbies, food, books, travel, etc.).
* **personality**: Traits and mood trends.
* **memories**: Key events or milestones.
* **preferences**: Conversation style and topics to avoid.
* **update\_log**: Historical log of profile updates.
* **timestamps**: Last updated, created at, and per-section timestamps.
* **status**: `"processing"` or `"ready"` to indicate profile readiness.
Here’s a partial example:
```json theme={null}
{
"profile_id": "abc123",
"status": "ready",
"summary": "Alex is a curious and introverted person from Berlin who enjoys photography and hiking. Recently adopted a cat named Luna.",
"core_info": {
"name": { "value": "Alex", "confidence": 0.95 },
"location": { "value": "Berlin", "confidence": 0.9 }
},
"interests": {
"hobbies": [
{ "value": "photography", "confidence": 0.9 },
{ "value": "hiking", "confidence": 0.85 }
],
"music": [{ "value": "indie rock", "confidence": 0.9 }]
},
"personality": {
"traits": [
{ "value": "curious", "confidence": 0.9 },
{ "value": "introverted", "confidence": 0.8 }
],
"mood_trends": {
"default": { "value": "calm", "confidence": 0.9 },
"recent": { "value": "excited", "confidence": 0.8 }
}
},
"memories": [
{
"event": "adopted a cat named Luna",
"date": "2024-01-20",
"importance": "high",
"confidence": 0.95
}
],
"last_updated": "2024-05-24T12:00:00Z",
"created_at": "2024-04-01T10:00:00Z"
}
```
***
## Searching & Summaries
* In the **dashboard**, you can search profiles by id.
* You’ll also receive a **generated summary** in the API response — ideal for LLMs or quick user overviews.
✅ **Profiles update automatically** as you send new data, adapting to evolving user or character contexts!
***
Want to see more fields? Check out the **Profile type** in the [API Reference](/api-reference/profile/get#response-profile).
# Search Profiles
Source: https://docs.getprofile-ai.com/builders/search-profiles
Our ✨ Smart Search ✨ API lets you find and browse profiles using both semantic vector search and classic search features like filtering, sorting, and pagination—all in a single request.
## Endpoint
```http theme={null}
GET /v1/search
```
***
## Description
This endpoint **combines**:
* **Vector search** for semantic, natural language queries.
* **Classic search** for field-based filtering, sorting, and pagination.
You can use them **together** or **separately**. If a `query` is provided, **vector search** is used to find the most similar profiles to your text. If no `query` is provided, results are listed based on your filters and sorting.
***
## Query Parameters
| Parameter | Type | Default | Description |
| ------------- | ------ | -------------- | ------------------------------------------------------------------------------------------------- |
| `query` | string | — | Natural language search text. If present, enables vector-based semantic search. |
| `sensitivity` | number | 63 | (Vector search only) Similarity threshold (0-100). Lower = more results; higher = stricter match. |
| `filterBy` | string | — | Field to filter by (`name`, `location`, `age`, `language`, `id`, etc.). |
| `filterValue` | string | — | Value to filter for. Case-insensitive partial matching. |
| `sortBy` | string | `last_updated` | Field to sort by (`last_updated`, `created_at`, `id`, `name`, etc.). |
| `sortOrder` | string | `desc` | Sorting order: `asc` or `desc`. |
| `page` | number | 1 | Page number for pagination. |
| `pageSize` | number | 10 | Number of profiles per page. |
***
## Behavior
### If `query` is provided:
* Uses **vector search** (AI embeddings) to find similar profiles.
* Results are always **ranked by similarity** (`similarityScore`).
* Classic sorting (`sortBy`) is ignored for vector search (limitation of vector search engines).
### If no `query` is provided:
* Classic search: results are filtered, sorted, and paginated as usual.
### If both `query` and filters are provided:
* Vector search results are **filtered** by `filterBy` and `filterValue` **after** vector search.
* Sorted by **similarity**.
***
## Example Request
```http theme={null}
GET /v1/smart-search?query=experienced+data+scientist+with+PhD+looking+for+job&filterBy=location&filterValue=California&sortBy=last_updated&sortOrder=desc&page=1&pageSize=10
```
***
## Example Response
```json theme={null}
{
"profiles": [
{
"profile_id": "abc123",
"tenant_id": "tenant123",
"status": "active",
"core_info": {
"name": "Jane Doe",
"location": "Helsinki",
"age": 35,
"language": "Finnish"
},
"last_updated": "2024-06-01T10:00:00Z",
"created_at": "2023-05-10T15:30:00Z",
"similarityScore": 0.92
},
...
],
"total": 10,
"page": 1,
"pageSize": 10
}
```
***
## Notes
* **Vector search** does **not support** custom `sortBy` fields—results are always sorted by `similarityScore` when `query` is used.
* If you need to sort vector search results by another field, consider **post-processing** in your application after fetching results.
* For **classic listing**, sorting works as expected for any `sortBy` field.
***
## Use Cases
* Discover profiles matching **natural language queries** like:
> “experienced data scientist with PhD looking for job”
* Filter results by **specific fields** like location or language.
* Paginate and load results seamlessly in your UI.
* Soon: create profile segments based on search results for targeted actions and campaigns.
***
## Conclusion
The **Smart Profiles Search API** is your single endpoint for **powerful, flexible profile discovery** — whether you’re listing profiles, doing semantic search, running marketing campaigns, or building internal tools.
Need help integrating? Let us know! [support@getprofile-ai.com](mailto:support@getprofile-ai.com)
# Submit Data
Source: https://docs.getprofile-ai.com/builders/submit-data
Submit raw data to the GetProfile API
To create or update a user profile, send data to our API endpoint:
```http theme={null}
POST /v1/profile/{profile_id}
```
## What to Send
* **profile\_id**: A unique identifier for the profile (e.g., a user or character ID in your app).
* **data**: The raw text or structured data you want us to analyze.
* **input\_type** *(optional)*: A short label describing the type of data (e.g., `"bio"`, `"conversation"`, `"activity_log"`, `"form"`). This can help with tracking and better profiling.
Example:
```bash theme={null}
curl -X POST "https://api.getprofile-ai.com/v1/profile/abc123" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"data": "Alex is a curious photographer from Berlin who loves indie music and hiking.",
"input_type": "bio"
}'
```
***
## Processing Model
* Your request is **accepted immediately** with a `202 Accepted` response.
* We process the data **asynchronously** in the background.
* When the processing is complete, the profile will be updated with the new insights.
This makes it easy to send data **continuously** — your profiles will evolve as new data comes in!
***
✅ **No raw data is stored long-term** — only the structured profile is kept.
🔒 **Input data is deleted** once the profile update is complete.
# Dashboard
Source: https://docs.getprofile-ai.com/dashboard
Manage your profiles, apps, track usage, and configure integrations in one place.
## App Management
* Create and manage apps (separate projects or tenants).
* Rotate or revoke API keys for security.
* View and manage team members — invite collaborators with role-based access (member or admin).
## Profile Viewer
* View all profiles stored for your app.
* Click into any profile to explore detailed information, memories, and personality data.
* Search profiles by name, traits, or any extracted field (coming soon).
* Filter profiles based on activity, last updated date, or custom tags (coming soon).
* See a quick summary of each profile: interests, mood trends, and key traits (coming soon).
Your [dashboard](https://getprofile-ai.com/dashboard) makes it easy to **explore and manage your user profiles**, giving you actionable insights at a glance.
## Smart Search
The new **[Smart Search](/builders/search-profiles)** feature combines **semantic vector search** with classic search and filtering tools:
* Use natural language queries to find and segment profiles (like “AI experts in Berlin”).
* Apply filters on top of search results, e.g. by `location`, `language`, or other fields.
* Sort and paginate results for better exploration.
* Powered by AI embeddings and classic queries, it’s fast and flexible.
Find and refine your results with just a few clicks — no complex queries or separate endpoints needed!
## Usage Insights
* Visualize your monthly usage with clear charts.
* Filter by request type and billing period.
* Understand how your plan limits apply to your actual usage.
## API Key Management
* Securely manage your apps’s API keys.
* Rotate keys instantly when needed.
* Use your API keys in your applications or integrations.
## Webhooks & Integrations
* Register outgoing webhooks to be notified when profiles are updated.
* View and manage webhook URLs (Zapier, custom endpoints, etc.).
* Keep your other systems in sync with real-time profile updates.
Everything you need to track and manage your profiling workflow — all in one clean, secure interface.
# Introduction
Source: https://docs.getprofile-ai.com/index
Welcome to the GetProfile documentation! Learn how to set up and use our API to extract profile information from your raw data using the power of AI.
## What is GetProfile?
GetProfile is an AI-powered API that extracts structured profile information from raw data. It uses advanced natural language processing to analyze unstructured data and maintain a comprehensive profile, including interests, preferences, events, mood and more.
Add profile extraction and advanced memory to your AI chatbots to enhance
user interactions and personalization.
Use GetProfile to create dynamic player and characters profiles that adapt
to user behavior, enhancing gameplay and engagement.
Integrate GetProfile into your CRM or marketing tools to analyze customer
interactions and create targeted campaigns based on user profiles.
Leverage GetProfile to analyze user-generated content and extract insights
about your audience, improving content strategy and engagement.
## How to use GetProfile
GetProfile is designed to be easy to use, and agnostic to the data source. You can use it with any raw data, such as chat logs, game events, or user interactions. The API processes the data and returns either a structured profile data that you can use in your applications, or a AI-generated summary of the profile that can be used for quick insights or to provide context to LLM models.
Everything is wrapped in a few simple REST API calls, so you can integrate it into your existing applications without any hassle. See API Reference for more details on how to use the API.
## Why GetProfile?
GetProfile is built on top of the latest advancements in AI and natural language processing, making it a powerful tool for extracting insights from raw data. It is designed to be flexible and adaptable to various use cases, whether you are building a chatbot, a game, or a marketing tool.
We are taking the complexity out of profile extraction, allowing you to focus on building great applications. With GetProfile, you can:
* **Enhance User Experience**: Provide personalized interactions based on user profiles.
* **Improve Engagement**: Create dynamic profiles that adapt to user behavior.
* **Gain Insights**: Analyze user interactions and extract valuable insights for your business.
# MCP Server
Source: https://docs.getprofile-ai.com/integrations/mcp
We offer a Model Context Protocol (MCP) server for the GetProfile API, so you can integrate real-time profile data directly into your LLM-powered tools.
**Model Context Protocol (MCP) is coming soon!**
We are excited to announce that GetProfile will soon support a Model Context Protocol (MCP) for our API. This will allow you to integrate real-time profile data directly into your LLM-powered tools, such as ChatGPT, Claude, or custom AI agents.
***
### What is MCP?
**Model Context Protocol (MCP)** is a secure, structured interface that allows AI assistants and LLM tools (like Claude, GPT-4, or LangChain agents) to **access external data sources** — in this case, the GetProfile API.
This lets your AI workflows pull **live profile data** (like interests, traits, and updates) directly from your tenant’s profiles in real time.
***
### Setting Up MCP with Claude Desktop (or other tools)
Follow these steps to connect Claude Desktop (or any MCP-compatible app) to our MCP server:
***
#### Install Claude Desktop
Download and install Claude Desktop from [claude.ai/download](https://claude.ai/download).
***
#### Access Developer Settings
* Open Claude Desktop.
* Click on the **Claude** menu in the top bar.
* Select **Settings**.
* Go to the **Developer** tab.
* Click **Edit Config** to open the configuration file.
***
#### Configure the MCP Server
In the `claude_desktop_config.json` file, add our **GetProfile MCP server** configuration:
```json theme={null}
{
"mcpServers": {
"getprofile": {
"command": "npx",
"args": ["-y", "mint-mcp add docs.getprofile-ai.com"],
"env": {
"API_KEY": "YOUR_API_KEY_HERE"
}
}
}
}
```
Replace `YOUR_API_KEY_HERE` with your tenant’s **API key** from the GetProfile dashboard.
✅ **Tip:** You can add multiple MCP servers if needed (like local filesystem, etc.).
***
#### 4️⃣ Restart Claude Desktop
Save your changes and restart Claude Desktop to activate the new MCP server configuration.
***
### Using MCP Tools with Claude
Once configured:
✅ Open a new conversation in Claude Desktop.
✅ Click the **Tools** icon in the chat window.
✅ You’ll see the **GetProfile MCP tool** available.
✅ You can now ask Claude to **fetch live profile data** using your tenant’s API key.
For example:
> “Show me Alex’s hobbies and mood.”
Claude will:
1️⃣ Identify the GetProfile MCP tool.
2️⃣ Request permission to use it.
3️⃣ Fetch the real-time profile data.
4️⃣ Provide the result in your conversation.
***
### 🔒 Security Considerations
* Claude (or any AI assistant) **asks for your permission** before running MCP tools.
* You can grant access **once** or for the entire conversation.
* Review each request to ensure you’re comfortable with the data shared.
***
### Troubleshooting
✅ Verify your **API key** is correct.
✅ Ensure you **restarted Claude Desktop** after configuration.
✅ Check that **Node.js and npx** are installed (`npx` is bundled with Node).
✅ If you see errors, review Claude’s logs for details.
***
### 🔗 Using with Other MCP-Compatible Tools
The GetProfile MCP server works with **any tool** that supports the Model Context Protocol — not just Claude Desktop.
Configuration steps may vary depending on the app, but the **core usage remains the same**:
* Point to the MCP server package
* Pass your **API key**
* Use live profile data in your LLM workflows!
***
🔗 **Questions?** Contact [support@getprofile-ai.com](mailto:support@getprofile-ai.com). We’re here to help you build richer, more dynamic AI experiences!
***
Would you like:
✅ A short **quickstart snippet** for another framework like LangChain?
✅ Or to generate a **video script** or animated GIF for social or docs?
Let me know — your MCP integration is ready to shine! 🚀✨
# Overview
Source: https://docs.getprofile-ai.com/integrations/overview
Integrate GetProfile with your favorite tools and services
GetProfile support a variety of ways to integrate with your app or service, to help you connect your user profiles with the tools you already use.
## Webhooks
Set up your own webhooks to receive real-time notifications whenever a profile is updated:
* Automate actions in your backend or other SaaS platforms.
* Create a fully customized profile-powered experience.
* Manage webhooks directly from your GetProfile [dashboard](https://getprofile-ai.com/dashboard).
[Learn more about Webhooks](/integrations/webhooks) and how to set them up.
## Zapier
Easily connect your profile updates to thousands of apps:
* Trigger workflows when a profile is updated.
* Enrich your CRM, marketing, or analytics tools with structured profiles.
* No code required — just configure your Zap!
[See our Zapier Integration Guide](/integrations/zapier) for setup instructions.
## Custom GPTs & OpenAI Assistants
Bring profiling data directly into your custom GPTs or Assistants:
* Use REST API to create tools for custom GPTs.
* Inject dynamic personality and preference data to create more natural and tailored conversations.
[See API reference](/api-reference) for details on how to use GetProfile REST API with OpenAI tools.
## Model Context Provider (MCP)
GetProfile also works as an MCP-compatible API, making it easy to integrate with modern AI platforms and assistants:
* Provide LLMs and other agents with up-to-date user profiles.
[Use our hosted MCP server](/integrations/mcp) for seamless tool integration.
## No-Code Tools: FlowXO, n8n & Make
Integrate GetProfile with powerful no-code automation platforms:
* **n8n**: Use HTTP request nodes to connect to GetProfile’s API and process profiles as part of larger workflows.
* **Make (formerly Integromat)**: Fetch profiles or send updates to create automations across your favorite apps.
* **FlowXO**: Use HTTP triggers and actions to connect GetProfile with your FlowXO bots and workflows.
No-code or low-code? No problem — GetProfile adapts to your stack.
## Other Ideas
GetProfile also works with:
* **Salesforce / HubSpot / CRMs**: Enrich customer data with structured profiles.
* **Game engines / Unity / Unreal / Godot**: Create dynamic character or player profiles in real time.
* **LlamaIndex / LangChain**: Use profiles as context or nodes in retrieval-augmented generation (RAG) flows.
***
Wherever you want rich, dynamic user profiles — GetProfile has you covered.
Want to see a specific example or tutorial? Reach out to our team!
# Webhooks
Source: https://docs.getprofile-ai.com/integrations/webhooks
Webhooks let you receive real-time notifications whenever important events happen in your GetProfile account or your tenant's profiles. Instead of polling the API, your app can respond immediately to changes.
With webhooks, you can:
* Keep your app’s database in sync with GetProfile
* Trigger custom workflows in real-time
* Monitor profile updates or billing events instantly
## How It Works
When an event occurs (like a profile update), GetProfile makes an HTTP POST request to the webhook URL you configured for your tenant. This request includes a JSON payload describing the event.
Your server should respond with a 200 OK status to acknowledge receipt.
## Example Webhook Event
Here’s an example of a profile.updated event:
```json theme={null}
{
"id": "evt_1234567890",
"event": "profile.updated",
"tenant_id": "abc-tenant",
"data": {
"profile_id": "12345",
"status": "ready"
},
"created_at": "2023-10-01T12:00:00Z",
"webhook_id": "webhook_12345"
}
```
## Available Events
| Event | Description |
| ----------------- | ---------------------------------- |
| `profile.updated` | Sent when a profile’s data changes |
## Configuring Webhooks
1. In your [GetProfile dashboard](https://getprofile-ai.com), navigate to `Webhooks`.
2. Click "Create webhook" button, enter the URL of your webhook endpoint (e.g., [https://yourapp.com/webhooks/getprofile](https://yourapp.com/webhooks/getprofile)).
3. Save the configuration.
You can update, turn off or delete the webhook at any time.
## Handling Webhook Requests
Your webhook endpoint should:
* Accept `POST` requests with `Content-Type: application/json`.
* Parse the JSON payload.
* Validate the request using the `Authorization` header.
* Respond with 200 OK quickly.
* Process the event asynchronously if needed.
### Example in Node.js Express
```javascript theme={null}
app.post("/webhooks/getprofile", express.json(), (req, res) => {
const authHeader = req.headers["authorization"];
if (!authHeader || !authHeader.startsWith("Bearer ")) {
return res
.status(401)
.send("Unauthorized: Missing or invalid Authorization header");
}
const incomingSecret = authHeader.split(" ")[1];
if (incomingSecret !== process.env.GETPROFILE_API_KEY) {
return res.status(401).send("Unauthorized: Invalid webhook secret");
}
const event = req.body;
console.log("Received webhook event:", event);
// TODO: process event here
res.status(200).send("OK");
});
```
## Security Best Practices
* Only accept requests from trusted sources.
* Validate the `Authorization` header before processing the event.
* Use HTTPS for your endpoint.
* Respond quickly (under 5 seconds) to avoid retries.
## API Reference
Webhooks API reference is coming soon.
# Zapier
Source: https://docs.getprofile-ai.com/integrations/zapier
GetProfile’s Zapier integration makes it easy to automate workflows and connect profile data to 6,000+ other apps — without writing code.
**Zapier integration is currently in beta.**
Join the beta program and start using it by following [this link](https://zapier.com/developer/public-invite/225843/51140746d59c9141578eba38c7dc9046/).
You can:
* Trigger actions in other apps when a profile is updated or created.
* Sync profile data to your CRM, marketing tools, or analytics platforms.
* Build complex workflows that react to real-time profile events.
## How It Works
* **Triggers**: When a profile is updated in GetProfile, Zapier triggers your workflow (Zap).
* **Actions**: Update, create or delete profiles directly from other apps.
### Example Use Cases
#### CRM Enrichment
Automatically add new profile insights to your CRM whenever a user’s profile updates.
#### Marketing Segmentation
Create targeted campaigns based on new hobbies, mood trends, or traits.
#### Internal Dashboards
Push profile updates to Notion, Airtable, or your internal tools for easy tracking.
***
## Security & API Key Management
* Your **API key** is required to connect GetProfile to Zapier.
* API keys can be rotated or revoked anytime from your dashboard.
* Only the data you share via Zapier triggers will be sent — no other profile data is exposed.
# Quickstart
Source: https://docs.getprofile-ai.com/quickstart
Get up and running with GetProfile in just a few minutes!
## 1. Sign up & create your app
* Create your free account on our [website](https://getprofile-ai.com/register).
* From your [dashboard](https://getprofile-ai.com/dashboard), create an **app** (e.g., "My AI App").
* Each app has a unique **API key** — keep it secure!
## 2. Send your first profiling request
Use our `POST /v1/profile/{id}` endpoint to send structured or unstructured data for analysis.
Example using `curl`:
```bash theme={null}
curl -X POST "https://api.getprofile-ai.com/v1/profile/abc123" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"data": "I love hiking and indie music.",
"input_type": "conversation"
}'
```
✅ You’ll get an immediate `202 Accepted` response while your data is processed in the background.
## 3. Retrieve the processed profile
Use our `GET /v1/profile/{id}` endpoint to get the structured profile data and a generated summary.
```bash theme={null}
curl -X GET "https://api.getprofile-ai.com/v1/profile/abc123" \
-H "Authorization: Bearer YOUR_API_KEY"
```
You’ll receive:
* `profile`: Full structured profile data
* `summary`: AI-generated summary for LLM usage
## 4. Update profile over time
You can send new data to the same profile ID multiple times — GetProfile will merge and evolve the profile automatically!
✅ Profiles grow and adapt as you learn more about your users or characters.
For complete details on all endpoints and optional fields, see the [API Reference](/api-reference).
# Node.js API Client
Source: https://docs.getprofile-ai.com/sdks/nodejs
A lightweight TypeScript client for the GetProfile API
Quickly integrate dynamic personality profiling into your Node.js and TypeScript applications.
***
## Features
* Submit any raw data (chat logs, bios, activity logs) to update profiles.
* Retrieve structured profiles: interests, personality, mood trends, and more.
* Delete profiles when needed.
* Secure, easy to use, and fully documented.
***
## Installation
```bash theme={null}
npm install getprofile-client
```
***
## Usage
```ts theme={null}
import { GetProfileClient } from "getprofile-client";
// Create a client instance
const client = new GetProfileClient({
apiKey: process.env.GETPROFILE_API_KEY!, // Your API key
});
async function run() {
// 1️⃣ Submit data to update the profile
await client.submitProfileUpdate(
"user123",
"Alex is a photographer who loves hiking and indie music.",
"bio"
);
// 2️⃣ Retrieve the structured profile
const profile = await client.getProfile("user123");
console.log("Profile:", profile);
// 3️⃣ Delete the profile if needed
// await client.deleteProfile("user123");
}
run().catch(console.error);
```
✅ **Pro Tip:** Use environment variables to store your API key for better security!
***
## License
MIT — feel free to use and contribute! Give it a star on [GitHub](https://github.com/getprofile/client) if you find it useful! 🌟
***
Have fun building smarter, more personalized experiences with **GetProfile**! 🚀