# What is AWS AppFabric for productivity?
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
**Note**
Powered by Amazon Bedrock: AWS implements automated abuse [detection](https://docs.aws.amazon.com/bedrock/latest/userguide/abuse-detection.html). Because AWS AppFabric for productivity is built on Amazon Bedrock, users inherit the controls implemented in Amazon Bedrock to enforce safety, security, and the responsible use of AI.
AWS AppFabric for productivity (preview) helps reimagine end-user productivity in third-party applications by generating insights and actions with context from multiple applications. App developers recognize that accessing user data from other apps is important in creating a more productive app experience, but they don’t want to build and manage integrations with each application. With AppFabric for productivity, application developers gain access to generative AI-powered APIs that generate cross-app data insights and actions so they can provide richer end-user experiences through new or existing generative AI assistants. AppFabric for productivity integrates data from multiple applications removing the need for developers to build or maintain point-to-point integrations. Application developers can embed AppFabric for productivity directly into their application’s UI, maintaining a consistent experience for their end users while surfacing relevant context from other applications.
AppFabric for productivity connects data from commonly used applications such as Asana, Atlassian Jira Suite, Google Workspace, Microsoft 365, Miro, Slack, Smartsheet, and more. AppFabric for productivity gives app developers an easier way to build more personalized app experiences that improve user adoption, satisfaction, and loyalty. Meanwhile, end users benefit from accessing insights they need from across their applications without interrupting their flow of work.
**Topics**
+ [Benefits](#benefits)
+ [Use cases](#use-cases)
+ [Accessing AppFabric for productivity](#acessing-appfabric)
+ [Get started with AppFabric for productivity (preview) for application developers](getting-started-appdeveloper-productivity.md)
+ [Get started with AppFabric for productivity (preview) for end users](getting-started-users-productivity.md)
+ [AppFabric for productivity APIs (preview)](productivity-apis.md)
+ [Data processing in AppFabric](productivity-data-processing.md)
## Benefits
With AppFabric for productivity, application developers gain access to APIs that generate cross-app data insights and actions so they can provide richer end-user experiences through new or existing generative AI assistants.
+ **Single source of cross-app user data**: AppFabric for productivity integrates data from multiple applications removing the need for developers to build or maintain point-to-point integrations. SaaS app data is processed for use in other applications by automatically normalizing disparate data types into a format understandable by any application, allowing app developers to incorporate more data that actually improves end users’ productivity.
+ **Full control of user experience**: Developers embed AppFabric for productivity directly into their application’s UI, retaining full control of the user experience while providing personalized insights and recommended actions to end users with context from across their applications. This makes AppFabric for productivity available in end users’ preferred SaaS application and is accessible in the app they prefer to complete their tasks. End users spend less time switching between apps, and can stay in the flow of their work.
+ **Accelerate time to market**: In a single API call, app developers can receive user-level insights across a user’s data that is generated without having to fine-tune a model, write a custom prompt, or build integrations across multiple applications. AppFabric abstracts out this complexity to enable app developers to build, embed, or enrich generative AI capabilities faster. This allows app developers to focus on their resources on the most important tasks.
+ **Artifact references to build user trust**: As part of the output, AppFabric for productivity will surface relevant artifacts or source files used to generate the insights to build end-user trust in the LLM outputs.
+ **Simplified user permissions**: User artifacts used to generate insights are based on what a user has access to. AppFabric for productivity uses the an ISV’s permission and access control as the source of truth.
## Use cases
App developers can use AppFabric for productivity to reimagine productivity inside their applications. AppFabric for productivity offers two APIs focused on the following use cases to help their end users be more productive:
+ Prioritize your day
+ The actionable insights API helps users best manage their day by surfacing timely insights from across their applications including emails, calendar, messages, tasks, and more. Additionally, users can execute cross-app actions such as creating emails, scheduling meetings, and creation action items from their preferred application. For example, an employee who had customer escalation overnight will not only see a summary of the overnight conversations, but will also be able to see a recommended action to schedule a meeting with the customer Account Manager. Actions are pre-populated with required fields (such as tasks name and owner, or email sender/recipient), with the ability to edit pre-populated content before executing the action.
+ Prepare for upcoming meetings
+ The meeting preparation API helps users best prepare for meetings by summarizing the meeting purpose and surfacing relevant cross-app artifacts such as emails, messages, and more. Users can quickly prepare for meetings now and don’t waste time switching between apps to find content.
## Accessing AppFabric for productivity
AppFabric for productivity is currently launched as a preview and available in the US East (N. Virginia) AWS Region. For more information about AWS Regions, see [AWS AppFabric endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/appfabric.html) in the *AWS General Reference*.
In each Region, you can access AppFabric for productivity in any of the following ways:
+ As an app developer
+ [Get started with AppFabric for productivity (preview) for application developers](getting-started-appdeveloper-productivity.md)
+ As an end user
+ [Get started with AppFabric for productivity (preview) for end users](getting-started-users-productivity.md)
# Get started with AppFabric for productivity (preview) for application developers
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
This section helps app developers integrate AWS AppFabric for productivity (preview) into their applications. AWS AppFabric for productivity enables developers to build richer app experiences for their users by generating AI-powered insights and actions from emails, calendar events, tasks, messages, and more across multiple applications. For a list of supported applications, see [AWS AppFabric Supported Applications](https://aws.amazon.com/appfabric/supported-applications/).
AppFabric for productivity offers app developers access to build and experiment within a secure and controlled environment. When you first start using AppFabric for productivity, you create an AppClient and register a single test user. This approach is designed to help you understand and test the authentication and communication flow between your application and AppFabric. After you've tested with a single user, you can submit your application to AppFabric for verification before expanding access to additional users (see [Step 5. Request AppFabric to verify your application](#request_verification)). AppFabric will verify application information before enabling wide spread adoption to help protect app developers, end users, and their data — paving the way for expanding user adoption in a responsible manner.
**Topics**
+ [Prerequisites](#getting-started-prerequisites)
+ [Step 1. Create an AppFabric for productivity AppClient](#create_appclient)
+ [Step 2. Authenticate and authorize your application](#authorize_data_access)
+ [Step 3. Add the AppFabric user portal URL to your application](#end_user_portal)
+ [Step 4. Use AppFabric to surface cross-app insights and actions](#surface_insights_actions)
+ [Step 5. Request AppFabric to verify your application](#request_verification)
+ [Manage AppFabric for productivity AppClients](manage-appclients.md)
+ [Troubleshoot AppClients in AppFabric for productivity](ahead-app-dev-errors.md)
## Prerequisites
Before you get started, you need to create an AWS account. For more information, see [Sign up for an AWS account](prerequisites.md#sign-up-for-aws). You also need to create at least one user with access to the `"appfabric:CreateAppClient"` IAM policy listed below, which allows the user to register your application with AppFabric. For more information about granting permissions for the AppFabric for productivity features, see [AppFabric for productivity IAM policy examples](security_iam_id-based-policy-examples.md#appfabric-for-productivity-policy-examples). While having an administrative user is beneficial, it's not mandatory for initial setup. For more information, see [Create a user with administrative access](prerequisites.md#create-an-admin).
AppFabric for productivity is only in US East (N. Virginia) during preview. Ensure you’re in this region before you start the steps below.
## Step 1. Create an AppFabric for productivity AppClient
Before you can start surfacing AppFabric for productivity insights within your application, you need to create an AppFabric AppClient. An AppClient is essentially your gateway to AppFabric for productivity, functioning as a secure OAuth application client enabling secure communication between your application and AppFabric. When you create an AppClient, you'll be provided with an AppClient ID, a unique identifier crucial for ensuring that AppFabric knows that it's working with your application and your AWS account.
AppFabric for productivity offers app developers access to build and experiment within a secure and controlled environment. When you first start using AppFabric for productivity, you create an AppClient and register a single test user. This approach is designed to help you understand and test the authentication and communication flow between your application and AppFabric. After you've tested with a single user, you can submit your application to AppFabric for verification before expanding access to additional users (see [Step 5. Request AppFabric to verify your application](#request_verification)). AppFabric will verify application information before enabling wide spread adoption to help protect app developers, end users, and their data — paving the way for expanding user adoption in a responsible manner.
To create an AppClient, use the AWS AppFabric `CreateAppClient` API operation. If you need to update the AppClient after, you can use the `UpdateAppClient` API operation to change only the redirectUrls. If you need to change any of the other parameters associated with your AppClient such as appName or description, you must delete the AppClient and create a new one. For more information, see [CreateAppClient](API_CreateAppClient.md).
You can register your application with AWS services using the `CreateAppClient` API using several programming languages, including Python, Node.js, Java, C\$1, Go and Rust. For more information, see [Request signature examples](https://docs.aws.amazon.com/IAM/latest/UserGuide/signature-v4-examples.html) in the *IAM User Guide*. You need to use your account signature version 4 credentials to perform this API operation. For more information about signature version 4, see [Signing AWS API requests](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html) in the *IAM User Guide*.
**Request Fields**
+ `appName` - The name of the application that will be displayed to the users on the consent page of the AppFabric user portal. The consent page asks end users for permission to display AppFabric insights inside your application. For details about the consent page, see [Step 2. Provide consent for the app to display insights](getting-started-users-productivity.md#provide-consent).
+ `description` - A description for the application.
+ `redirectUrls` - The URI to redirect end users to after authorization. You can add up to 5 redirectUrls. For example, `https://localhost:8080`.
+ `starterUserEmails` - A user email address that will be allowed access to receive the insights until the application is verified. Only one email address is allowed. For example, `anyuser@example.com`
+ `customerManagedKeyIdentifier` (optional) - The ARN of the customer managed key (generated by KMS) to be used to encrypt the data. If not specified, then AWS AppFabric managed key will be used. For more information about AWS owned keys and customer managed keys, see [Customer keys and AWS keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-mgmt) in the *AWS Key Management Service Developer Guide*.
**Response Fields**
+ `appClientArn` - The Amazon Resource Name (ARN) that includes the AppClient ID. For example, the AppClient ID is `a1b2c3d4-5678-90ab-cdef-EXAMPLE11111`.
+ `verificationStatus` - The AppClient verification status.
+ `pending_verification` - The verification of the AppClient is still in progress with AppFabric. Until the AppClient is verified, only one user (specified in `starterUserEmails`) can use the AppClient. The user will see a notification in the AppFabric user portal, introduced in [Step 3. Add the AppFabric user portal URL to your application](#end_user_portal), indicating that the application isn't verified.
+ `verified` - The verification process has been successfully completed by AppFabric and the AppClient is now fully verified.
+ `rejected` - The verification process for the AppClient was rejected by AppFabric. The AppClient cannot be used by additional users until the verification process is re-initiated and completed successfully.
```
curl --request POST \
--header "Content-Type: application/json" \
--header "X-Amz-Content-Sha256: " \
--header "X-Amz-Security-Token: " \
--header "X-Amz-Date: 20230922T172215Z" \
--header "Authorization: AWS4-HMAC-SHA256 ..." \
--url https://appfabric..amazonaws.com/appclients/ \
--data '{
"appName": "Test App",
"description": "This is a test app",
"redirectUrls": ["https://localhost:8080"],
"starterUserEmails": ["anyuser@example.com"],
"customerManagedKeyIdentifier": "arn:aws:kms:::key/"
}'
```
If the action is successful, the service sends back an HTTP 200 response.
```
{
"appClientConfigSummary": {
"appClientArn": "arn:aws:appfabric:::appclient/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"verificationStatus": "pending_verification"
}
}
```
## Step 2. Authenticate and authorize your application
Enable your application to securely integrate AppFabric insights by establishing an OAuth 2.0 authorization flow. First, you need to create an authorization code, which verifies your application identity. For more information, see [Authorize](API_Authorize.md). Then you'll exchange this authorization code for an access token, which grants your application the permissions to fetch and display AppFabric insights within your application. For more information, see [Token](API_Token.md).
For more information about granting permission to authorize an application, see [Allow access to authorize applications](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-productivity-token).
1. To create an authorization code, use the AWS AppFabric `oauth2/authorize` API operation.
**Request Fields**
+ `app_client_id` (required) - The AppClient ID for the AWS account created in [Step 1. Create an AppClient](#create_appclient). For example, `a1b2c3d4-5678-90ab-cdef-EXAMPLE11111`.
+ `redirect_uri` (required) - The URI to redirect end users to after authorization you used in [Step 1. Create an AppClient](#create_appclient). For example, `https://localhost:8080`.
+ `state` (required) - A unique value to maintain the state between the request and callback. For example, `a8904edc-890c-1005-1996-29a757272a44`.
```
GET https://productivity.appfabric..amazonaws.com/oauth2/authorize?app_client_id=a1b2c3d4-5678-90ab-cdef-EXAMPLE11111\
redirect_uri=https://localhost:8080&state=a8904edc-890c-1005-1996-29a757272a44
```
1. After authentication, you’ll be redirected to the specified URI with an authorization code returned as a query parameter. For example, where `code=mM0NyJ9.MEUCIHQQgV3ChXGs2LRwxLtpsgya3ybfPYXfX-sxTAdRF-gDAiEAxX7BYKlD9krG3J2VtprOjVXZ0FSUX9whdekqJ-oampc`.
```
https://localhost:8080/?code=mM0NyJ9.MEUCIHQQgV3ChXGs2LRwxLtpsgya3ybfPYXfX-sxTAdRF-gDAiEAxX7BYKlD9krG3J2VtprOjVXZ0FSUX9whdekqJ-oampc&state=a8904edc-890c-1005-1996-29a757272a44
```
1. Exchange this authorization code for an access token using the AppFabric `oauth2/token` API operation.
This token is used for API requests and is initially valid for the `starterUserEmails` until the AppClient is verified. After the AppClient is verified, this token can be used for any user. You need to use your account signature version 4 credentials to perform this API operation. For more information about signature version 4, see [Signing AWS API requests](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html) in the *IAM User Guide*.
**Request Fields**
+ `code` (required) - The authorization code you received after authenticating in the last step. For example, `mM0NyJ9.MEUCIHQQgV3ChXGs2LRwxLtpsgya3ybfPYXfX-sxTAdRF-gDAiEAxX7BYKlD9krG3J2VtprOjVXZ0FSUX9whdekqJ-oampc`.
+ `app_client_id` (required) - The AppClient ID for the AWS account created in [Step 1. Create an AppClient](#create_appclient). For example, `a1b2c3d4-5678-90ab-cdef-EXAMPLE11111`.
+ `grant_type` (required) - The value must be `authorization_code`.
+ `redirect_uri` (required) - The URI to redirect users to after authorization you used in [Step 1. Create an AppClient](#create_appclient). This must be the same redirect URI used to create an authorization code. For example, `https://localhost:8080`.
**Response Fields**
+ `expires_in` - How soon before the token expires. The default expiration time is 12 hours.
+ `refresh_token` - The refresh token received from the initial /token request.
+ `token` - The token received from the initial /token request.
+ `token_type` - The value will be `Bearer`.
+ `appfabric_user_id` - The AppFabric user id. This is returned only for requests that use the `authorization_code` grant type.
```
curl --location \
"https://appfabric..amazonaws.com/oauth2/token" \
--header "Content-Type: application/json" \
--header "X-Amz-Content-Sha256: " \
--header "X-Amz-Security-Token: " \
--header "X-Amz-Date: 20230922T172215Z" \
--header "Authorization: AWS4-HMAC-SHA256 ..." \
--data "{
\"code\": \"mM0NyJ9.MEUCIHQQgV3ChXGs2LRwxLtpsgya3ybfPYXfX-sxTAdRF-gDAiEAxX7BYKlD9krG3J2VtprOjVXZ0FSUX9whdekqJ-oampc",
\"app_client_id\": \"a1b2c3d4-5678-90ab-cdef-EXAMPLE11111\",
\"grant_type\": \"authorization_code\",
\"redirect_uri\": \"https://localhost:8080\"
}"
```
If the action is successful, the service sends back an HTTP 200 response.
```
{
"expires_in": 43200,
"refresh_token": "apkaeibaerjr2example",
"token": "apkaeibaerjr2example",
"token_type": "Bearer",
"appfabric_user_id" : ""
}
```
## Step 3. Add the AppFabric user portal URL to your application
End users need to authorize AppFabric to access data from their applications that are used to generate insights. AppFabric removes the complexity for app developers to own this process by building a dedicated user portal (a pop-up screen) for end users to authorize their apps. When users are ready to enable AppFabric for productivity, they'll be taken to the user portal which enables them to connect and manage applications used to generate insights and cross-app actions. When logged in, users can connect applications to AppFabric for productivity and then go back to your application to explore the insights and actions. To integrate your application with AppFabric for productivity, you need to add a specific AppFabric URL to your application. This step is crucial for enabling users to access the AppFabric user portal directly from your application.
1. Navigate to your application’s settings and locate the section for adding redirect URLs.
1. After you find the appropriate area, add the following AppFabric URL as a redirect URL to your application:
```
https://userportal.appfabric..amazonaws.com/eup_login
```
After you add the URL, your application will be set up to direct users to the AppFabric user portal. Here, users can log in and connect and manage their applications used to generate AppFabric for productivity insights.
## Step 4. Use AppFabric to surface cross-app insights and actions
After users connect their applications, you can bring your user’s insights to improve their productivity by helping reducing app and context switching. AppFabric only generates insight for a user based on what the user has permission to access. AppFabric stores user data in an AWS account owned by AppFabric. For information about how AppFabric uses your data, see [Data processing in AppFabric](productivity-data-processing.md).
You can use the following AI-powered APIs to generate and surface user-level insights and actions within your apps:
+ `ListActionableInsights` — For more information, see the [Actionable insights](#productivity-actionable-insights) section below.
+ `ListMeetingInsights` — For more information, see the [Meeting preparation](#productivity-meeting-insights) section later in this guide.
### Actionable insights (`ListActionableInsights`)
The `ListActionableInsights` API helps users best manage their day surfacing actionable insights based on activity across their applications, including emails, calendar, messages, tasks, and more. Returned insights will also show embedded links to artifacts used to generate the insight — helping users to quickly view what data was used to generate the insight. Additionally, the API may return suggested actions based on the insight and allow users to execute cross-app actions from within your application. Specifically, the API integrates with platforms like Asana, Google Workspace, Microsoft 365, and Smartsheet to enable users to send emails, create calendar events, and create tasks. The large language models (LLMs) may pre-populate details within a recommended action (such as email body or task name), which users can customize before execution — simplifying decision-making and enhancing productivity. Similar to the experience for end users to authorize applications, AppFabric uses the same dedicated portal for users to view, edit, and execute cross-app actions. For executing actions, AppFabric requires ISVs to re-direct users to a AppFabric user portal where they can see action details and execute them. Every action generated by AppFabric has a unique URL. This URL is available in the response of `ListActionableInsights` API response.
Below is a summary of the supported cross-app actions and in which apps:
+ Send email (Google Workspace, Microsoft 365)
+ Create calendar event (Google Workspace, Microsoft 365)
+ Create task (Asana, Smartsheet)
**Request Fields**
+ `nextToken` (optional) - The pagination token to fetch the next set of insights.
+ `includeActionExecutionStatus` - A filter which accepts list of action execution statuses. The actions are filtered based on status values passed in. Possible values: `NOT_EXECUTED` \$1 `EXECUTED`
**Request Header**
+ Authorization header needs to be passed in with the `Bearer Token `value.
**Response Fields**
+ `insightId` - The unique id for the generated insight.
+ `insightContent` - This returns a summary of the insight and embedded links to artifacts used to generate the insight. Note: This would be an HTML content containing embedded links ( tags).
+ `insightTitle` - The title of the generated insight.
+ `createdAt` - When the insight was generated.
+ `actions` - A list of actions recommend for the generated insight. Action object:
+ `actionId` - The unique id for the generated action.
+ `actionIconUrl` - The icon URL for the app that the action is suggested to be executed in.
+ `actionTitle` - The title of the generated action.
+ `actionUrl` - The unique URL for the end user to view and execute the action in AppFabric’s user portal. Note: for executing actions, ISV apps will re-direct users to AppFabric user portal (pop up screen) using this URL.
+ `actionExecutionStatus` - An enum indicating the status of the action. The possible values are: `EXECUTED` \$1 `NOT_EXECUTED`
+ `nextToken` (optional) - The pagination token to fetch the next set of insights. It’s an optional field which if returned null means there are no more insights to load.
For more information, see [ActionableInsights](API_ActionableInsights.md).
```
curl -v --location \
"https://productivity.appfabric..amazonaws.com"\
"/actionableInsights" \
--header "Authorization: Bearer "
```
If the action is successful, the service sends back an HTTP 200 response.
```
200 OK
{
"insights": [
{
"insightId": "7tff3412-33b4-479a-8812-30EXAMPLE1111",
"insightContent": "You received an email from James
regarding providing feedback
for upcoming performance reviews.",
"insightTitle": "New feedback request",
"createdAt": 2022-10-08T00:46:31.378493Z,
"actions": [
{
"actionId": "5b4f3412-33b4-479a-8812-3EXAMPLE2222",
"actionIconUrl": "https://d3gdwnnn63ow7w.cloudfront.net/eup/123.svg",
"actionTitle": "Send feedback request email",
"actionUrl": "https://userportal.appfabric.us-east-1.amazonaws.com/action/action_id_1"
"actionExecutionStatus": "NOT_EXECUTED"
}
]
},
{
"insightId": "2dff3412-33b4-479a-8812-30bEXAMPLE3333",
"insightContent":"Steve sent you an email asking for details on project. Consider replying to the email.",
"insightTitle": "New team launch discussion",
"createdAt": 2022-10-08T00:46:31.378493Z,
"actions": [
{
"actionId": "74251e31-5962-49d2-9ca3-1EXAMPLE1111",
"actionIconUrl": "https://d3gdwnnn63ow7w.cloudfront.net/eup/123.svg",
"actionTitle": "Reply to team launch email",
"actionUrl": "https://userportal.appfabric.us-east-1.amazonaws.com/action/action_id_2"
"actionExecutionStatus": "NOT_EXECUTED"
}
]
}
],
"nextToken": null
}
```
### Meeting preparation (`ListMeetingInsights`)
The `ListMeetingInsights` API helps users best prepare for upcoming meetings by summarizing the meeting purpose and surfacing relevant cross-app artifacts such as emails, messages, and more. Users can quickly prepare for meetings now and don’t waste time switching between apps to find content.
**Request Fields**
+ `nextToken` (optional) - The pagination token to fetch the next set of insights.
**Request Header**
+ Authorization header needs to be passed in with the `Bearer Token` value.
**Response Fields**
+ `insightId` - The unique id for the generated insight.
+ `insightContent` - The description of the insight highlighting the details in a string format. As in, why is this insight important.
+ `insightTitle` - The title of the generated insight.
+ `createdAt` - When the insight was generated.
+ `calendarEvent` - The important calendar event or meeting that the user should focus on. Calendar Event object:
+ `startTime` - The start time of the event.
+ `endTime` - The end time of the event.
+ `eventUrl` - The URL for the calendar event on the ISV app.
+ `resources` - The list containing the other resources related to the generate the insight. Resource object:
+ `appName` - The app name to which the resource belongs.
+ `resourceTitle` - The resource title.
+ `resourceType` - The type of the resource. The possible values are: `EMAIL` \$1 `EVENT` \$1 `MESSAGE` \$1 `TASK`
+ `resourceUrl` - The resource URL in the app.
+ `appIconUrl` - The image URL of the app to which the resource belongs.
+ `nextToken` (optional) - The pagination token to fetch the next set of insights. It’s an optional field which if returned null means there are no more insights to load.
For more information, see [MeetingInsights](API_MeetingInsights.md).
```
curl --location \
"https://productivity.appfabric..amazonaws.com"\
"/meetingContexts" \
--header "Authorization: Bearer "
```
If the action is successful, the service sends back an HTTP 201 response.
```
200 OK
{
"insights": [
{
"insightId": "74251e31-5962-49d2-9ca3-15EXAMPLE4444"
"insightContent": "Project demo meeting coming up soon. Prepare accordingly",
"insightTitle": "Demo meeting next week",
"createdAt": 2022-10-08T00:46:31.378493Z,
"calendarEvent": {
"startTime": {
"timeInUTC": 2023-10-08T10:00:00.000000Z,
"timeZone": "UTC"
},
"endTime": {
"timeInUTC": 2023-10-08T11:00:00.000000Z,
"timeZone": "UTC"
},
"eventUrl": "http://someapp.com/events/1234",
}
"resources": [
{
"appName": "SOME_EMAIL_APP",
"resourceTitle": "Email for project demo",
"resourceType": "EMAIL",
"resourceUrl": "http://someapp.com/emails/1234",
"appIconUrl":"https://d3gdwnnn63ow7w.cloudfront.net/eup/123.svg"
}
]
},
{
"insightId": "98751e31-5962-49d2-9ca3-15EXAMPLE5555"
"insightContent": "Important code complete task is now due. Consider updating the status.",
"insightTitle": "Code complete task is due",
"createdAt": 2022-10-08T00:46:31.378493Z,
"calendarEvent":{
"startTime": {
"timeInUTC": 2023-10-08T10:00:00.000000Z,
"timeZone": "UTC"
},
"endTime": {
"timeInUTC": 2023-10-08T11:00:00.000000Z,
"timeZone": "UTC"
},
"eventUrl": "http://someapp.com/events/1234",
},
"resources": [
{
"appName": "SOME_TASK_APPLICATION",
"resourceTitle": "Code Complete task is due",
"resourceType": "TASK",
"resourceUrl": "http://someapp.com/task/1234",
"appIconUrl": "https://d3gdwnnn63ow7w.cloudfront.net/eup/123.svg"
}
]
}
],
"nextToken": null
}
```
### Provide feedback for your insights or actions
Use the AppFabric `PutFeedback` API operation to provide feedback for the generated insights and actions. You can embed this feature in your apps to provide a way to submit a feedback rating (1 to 5, where the higher rating the better) for a given InsightId or ActionId.
**Request fields**
+ `id` - The identifier of the object for which feedback is being submitted. This can be either the InsightId or the ActionId.
+ `feedbackFor` - The resource type for which feedback is being submitted. Possible values: `ACTIONABLE_INSIGHT` \$1 `MEETING_INSIGHT` \$1 `ACTION`
+ `feedbackRating` - Feedback rating from `1` to `5`. Higher rating the better.
**Response fields**
+ There are no response fields.
For more information, see [PutFeedback](API_PutFeedback.md).
```
curl --request POST \
--url "https://productivity.appfabric..amazonaws.com"\
"/feedback" \
--header "Authorization: Bearer " \
--header "Content-Type: application/json" \
--data '{
"id": "1234-5678-9012",
"feedbackFor": "ACTIONABLE_INSIGHT"
"feedbackRating": 3
}'
```
If the action is successful, the service sends back an HTTP 201 response with an empty HTTP body.
## Step 5. Request AppFabric to verify your application
To this point, you've updated your application UI to embed AppFabric cross-app insights and actions, and received insights for a single user. After you’re satisfied with testing and want to extend your AppFabric-enriched experience to additional users, you can submit your application to AppFabric for review and verification. AppFabric will verify application information before enabling wide spread adoption to help protect app developers, end users, and their data — paving the way for expanding user adoption in a responsible manner.
**Initiate the verification process**
Begin the verification process by sending an email to [appfabric-appverification@amazon.com](mailto:appfabric-appverification@amazon.com) and requesting that your app be verified.
Include the following details in your email:
+ Your AWS account ID
+ The name of the application you're seeking verification for
+ Your AppClient ID
+ Your contact information
Additionally, provide the following information, if available, to help us assess priority and impact:
+ An estimated number of users you plan to grant access to
+ Your target launch date
**Note**
If you have an AWS account manager or AWS partner development manager, please copy them on your email. Including these contacts can help expedite the verification process.
**Verification criteria**
Before initiating the verification process, you must meet the following criteria:
+ You must use a valid AWS account to use AppFabric for productivity
Additionally, you meet at least one of these criteria:
+ Your organization is an AWS partner on the AWS Partner Network with at least an “AWS Select” tier. For more information, see [AWS Partner Services Tiers](https://aws.amazon.com/partners/services-tiers/).
+ Your organization should have spent at least \$110,000 on AppFabric services within the last three years.
+ Your application should be listed on the AWS Marketplace. For more information, see the [AWSMarketplace](https://aws.amazon.com/marketplace).
**Await verification status update**
After your application is reviewed, we'll respond via email and the status of your AppClient will change from `pending_verification` to `verified`. If your application is rejected, you’ll need to re-initiate the verification process.
# Manage AppFabric for productivity AppClients
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
You can manage your AppFabric for productivity AppClients to ensure smooth operation and maintenance of authentication and authorization processes.
## Get details of an AppClient
Use the AppFabric `GetAppClient` API operation to view details about your AppClient, including checking the AppClient status. For more information, see [GetAppClient](API_GetAppClient.md).
To get details of an AppClient, you must have, at minimum, the `"appfabric:GetAppClient"` IAM policy permissions. For more information, see [Allow access to get details of AppClients](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-productivity-get-appclient).
**Request Fields**
+ `appClientId` - The AppClient Id.
**Response Fields**
+ `appName` - The name of the application that will be displayed to the users on the consent page of the AppFabric user portal.
+ `customerManagedKeyIdentifier` (optional) - The ARN of the Customer Managed Key (generated by KMS) to be used to encrypt the data. If not specified, then AWS AppFabric Managed Key will be used.
+ `description` - A description for the application.
+ `redirectUrls` - The URI to redirect end users to after authorization. You can add up to 5 redirectUrls. For example, `https://localhost:8080`.
+ `starterUserEmails` - A user email address that will be allowed access to receive the insights until the application is verified. Only one email address is allowed. For example, `anyuser@example.com`.
+ `verificationStatus` - The AppClient verification status.
+ `pending_verification` - The verification of the AppClient is still in progress with AppFabric. Until the AppClient is verified, only one user (specified in `starterUserEmails`) can use the AppClient.
+ `verified` - The verification process has been successfully completed by AppFabric and the AppClient is now fully verified.
+ `rejected` - The verification process for the AppClient was rejected by AppFabric. The AppClient cannot be used by additional users until the verification process is re-initiated and completed successfully.
```
curl --request GET \
--header "Content-Type: application/json" \
--header "X-Amz-Content-Sha256: " \
--header "X-Amz-Security-Token: " \
--header "X-Amz-Date: 20230922T172215Z" \
--header "Authorization: AWS4-HMAC-SHA256 ..." \
--url https://appfabric..amazonaws.com/appclients/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111
```
If the action is successful, the service sends back an HTTP 200 response.
```
200 OK
{
"appClient": {
"appName": "Test App",
"arn": "arn:aws:appfabric::111122223333:appclient/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"customerManagedKeyArn": "arn:aws:kms::111122223333:key/",
"description": "This is a test app",
"redirectUrls": [
"https://localhost:8080"
],
"starterUserEmails": [
"anyuser@example.com"
],
"verificationDetails": {
"verificationStatus": "pending_verification"
}
}
}
```
## List AppClients
Use the AppFabric `ListAppClients` API operation to view a list of your AppClients. AppFabric only allows one AppClient per AWS account. This is subject to change in the future. For more information, see [ListAppClients](API_ListAppClients.md).
To list AppClients, you must have, at minimum, the `"appfabric:ListAppClients"` IAM policy permissions. For more information, see [Allow access to list AppClients](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-productivity-list-appclient).
**Request Fields**
+ There are no required fields.
**Response Fields**
+ `appClientARN` - The Amazon Resource Name (ARN) that includes the AppClient ID. For example, the AppClient ID is `a1b2c3d4-5678-90ab-cdef-EXAMPLE11111`.
+ `verificationStatus` - The AppClient verification status.
+ `pending_verification` - The verification of the AppClient is still in progress with AppFabric. Until the AppClient is verified, only one user (specified in `starterUserEmails`) can use the AppClient.
+ `verified` - The verification process has been successfully completed by AppFabric and the AppClient is now fully verified.
+ `rejected` - The verification process for the AppClient was rejected by AppFabric. The AppClient cannot be used by additional users until the verification process is re-initiated and completed successfully.
```
curl --request GET \
--header "Content-Type: application/json" \
--header "X-Amz-Content-Sha256: " \
--header "X-Amz-Security-Token: " \
--header "X-Amz-Date: 20230922T172215Z" \
--header "Authorization: AWS4-HMAC-SHA256 ..." \
--url https://appfabric..amazonaws.com/appclients
```
If the action is successful, the service sends back an HTTP 200 response.
```
200 OK
{
"appClientList": [
{
"appClientArn": "arn:aws:appfabric::111122223333:appclient/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"verificationStatus": "pending_verification"
}
]
}
```
## Update an AppClient
Use the AppFabric `UpdateAppClient` API operation to update the redirectUrls mapped to your AppClient. If you need to change any other parameters, such as AppName, starterUserEmails, or other, you must delete the AppClient and create a new one. For more information, see [UpdateAppClient](API_UpdateAppClient.md).
To update an AppClient, you must have, at minimum, the `"appfabric:UpdateAppClient"` IAM policy permissions. For more information, see [Allow access to update AppClients](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-productivity-update-appclient).
**Request Fields**
+ `appClientId` (required) - The AppClient ID that you're updating the redirectUrls.
+ `redirectUrls` (required) - The updated list of the redirectUrls. You can add up to 5 redirectUrls.
**Response Fields**
+ `appName` - The name of the application that will be displayed to the users on the consent page of the AppFabric user portal.
+ `customerManagedKeyIdentifier` (optional) - The ARN of the Customer Managed Key (generated by KMS) to be used to encrypt the data. If not specified, then AWS AppFabric Managed Key will be used.
+ `description` - A description for the application.
+ `redirectUrls` - The URI to redirect end users to after authorization. For example, `https://localhost:8080`.
+ `starterUserEmails` - A user email address that will be allowed access to receive the insights until the application is verified. Only one email address is allowed. For example, `anyuser@example.com`.
+ `verificationStatus` - The AppClient verification status.
+ `pending_verification` - The verification of the AppClient is still in progress with AppFabric. Until the AppClient is verified, only one user (specified in `starterUserEmails`) can use the AppClient.
+ `verified` - The verification process has been successfully completed by AppFabric and the AppClient is now fully verified.
+ `rejected` - The verification process for the AppClient was rejected by AppFabric. The AppClient cannot be used by additional users until the verification process is re-initiated and completed successfully.
```
curl --request PATCH \
--header "Content-Type: application/json" \
--header "X-Amz-Content-Sha256: " \
--header "X-Amz-Security-Token: " \
--header "X-Amz-Date: 20230922T172215Z" \
--header "Authorization: AWS4-HMAC-SHA256 ..." \
--url https://appfabric..amazonaws.com/appclients/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111 \
--data '{
"redirectUrls": ["https://localhost:8081"]
}'
```
If the action is successful, the service sends back an HTTP 200 response.
```
200 OK
{
"appClient": {
"appName": "Test App",
"arn": "arn:aws:appfabric::111122223333:appclient/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"customerManagedKeyArn": "arn:aws:kms::111122223333:key/",
"description": "This is a test app",
"redirectUrls": [
"https://localhost:8081"
],
"starterUserEmails": [
"anyuser@example.com"
],
"verificationDetails": {
"verificationStatus": "pending_verification"
}
}
}
```
## Delete an AppClient
Use the AppFabric `DeleteAppClient` API operation to delete any AppClients you no longer need. For more information, see [DeleteAppClient](API_DeleteAppClient.md).
To delete an AppClient, you must have, at minimum, the `"appfabric:DeleteAppClient"` IAM policy permissions. For more information, see [Allow access to delete AppClients](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-productivity-delete-appclient).
**Request fields**
+ `appClientId` - The AppClient Id.
**Response fields**
+ There are no response fields.
```
curl --request DELETE \
--header "Content-Type: application/json" \
--header "X-Amz-Content-Sha256: " \
--header "X-Amz-Security-Token: " \
--header "X-Amz-Date: 20230922T172215Z" \
--header "Authorization: AWS4-HMAC-SHA256 ..." \
--url https://appfabric..amazonaws.com/appclients/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111
```
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.
## Refresh tokens for end users
The tokens your AppClient acquires for end users can be refreshed on expiry. This can be done using the [Token](API_Token.md) API with the grant\$1type `refresh_token`. The `refresh_token` to be used is returned as part of the token API response when the grant\$1type is `authorization_code`. The default expirations is 12 hours. To call the refresh API, you must have the `"appfabric:Token"` IAM policy permission. For more information, see [Token](API_Token.md) and [Allow access to update AppClients](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-productivity-update-appclient).
**Request Fields**
+ `refresh_token` (required) - The refresh token received from the initial `/token` request.
+ `app_client_id` (required) - The ID of the AppClient resource created for the AWS account.
+ `grant_type` (required) - This must be `refresh_token`.
**Response Fields**
+ `expires_in` - How soon before the token expires. The default expiration time is 12 hours.
+ `refresh_token` - The refresh token received from the initial /token request.
+ `token` - The token received from the initial /token request.
+ `token_type` - The value will be `Bearer`.
+ `appfabric_user_id` - The AppFabric user id. This is returned only for requests that use the `authorization_code` grant type.
```
curl --location \
"https://appfabric..amazonaws.com/oauth2/token" \
--header "Content-Type: application/json" \
--header "X-Amz-Content-Sha256: " \
--header "X-Amz-Security-Token: " \
--header "X-Amz-Date: 20230922T172215Z" \
--header "Authorization: AWS4-HMAC-SHA256 ..." \
--data "{
\"refresh_token\": \"",
\"app_client_id\": \"a1b2c3d4-5678-90ab-cdef-EXAMPLE11111\",
\"grant_type\": \"refresh_token\"
}"
```
If the action is successful, the service sends back an HTTP 200 response.
```
200 OK
{
"expires_in": 43200,
"token": "apkaeibaerjr2example",
"token_type": "Bearer",
"appfabric_user_id" : "${UserID}"
}
```
# Troubleshoot AppClients in AppFabric for productivity
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
This section describes common errors and troubleshooting for AppFabric for productivity.
## Unverified application
App developers that use AppFabric for productivity to enrich their app experiences will go through a verification process prior to launching their features to end users. All applications start as unverified and change to verified only when the verification process is complete. This means that the `starterUserEmails` you used when creating an AppClient will see this message.
![\[Warning message for an unverified application in AWS AppFabric, requesting data access.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-24.png)
## `CreateAppClient` errors
### ServiceQuotaExceededException
If you receive the following exception when creating an AppClient, you've exceeded the number of AppClients that can be created per AWS account. The limit is 1. HTTP Status Code: 402
```
ServiceQuotaExceededException / SERVICE_QUOTA_EXCEEDED
You have exceeded the number of AppClients that can be created per AWS Account. The limit is 1.
HTTP Status Code: 402
```
## `GetAppClient` errors
### ResourceNotFoundException
If you receive the following exception when getting details for an AppClient, ensure you’ve entered the correct AppClient identifier. This error signifies that the specified AppClient was not found.
```
ResourceNotFoundException / APP_CLIENT_NOT_FOUND
The specified AppClient is not found. Ensure you’ve entered the correct AppClient identifier.
HTTP Status Code: 404
```
## `DeleteAppClient` errors
### ConflictException
If you receive the following exception when deleting an AppClient, another delete request is in progress. Wait until it completes then try again. HTTP Status Code: 409
```
ConflictException
Another delete request is in progress. Wait until it completes then try again.
HTTP Status Code: 409
```
### ResourceNotFoundException
If you receive the following exception when deleting an AppClient, ensure you’ve entered the correct AppClient identifier. This error signifies that the specified AppClient was not found.
```
ResourceNotFoundException / APP_CLIENT_NOT_FOUND
The specified AppClient is not found. Ensure you’ve entered the correct AppClient identifier.
HTTP Status Code: 404
```
## `UpdateAppClient` errors
### ResourceNotFoundException
If you receive the following exception when updating an AppClient, ensure you’ve entered the correct AppClient identifier. This error signifies that the specified AppClient was not found.
```
ResourceNotFoundException / APP_CLIENT_NOT_FOUND
The specified AppClient is not found. Ensure you’ve entered the correct AppClient identifier.
HTTP Status Code: 404
```
## `Authorize` errors
### ValidationException
You might receive the following exception if any of the API parameters don’t satisfy the constraints defined in the API specifications.
```
ValidationException
HTTP Status Code: 400
```
**Reason 1: When AppClient ID is not specified**
The `app_client_id` is missing in the request parameters. Create the AppClient if it hasn't yet been created or use your existing `app_client_id` and try again. To find the AppClient ID, use the [ListAppClient](manage-appclients.md#list_appclients) API operation.
**Reason 2: When AppFabric doesn’t have access to the customer managed key**
```
Message: AppFabric couldn't access the customer managed key configured for AppClient.
```
AppFabric is currently unable to access the customer managed keys, likely due to recent changes in its permissions. Verify the specified key exists and ensure AppFabric is granted the appropriate access permissions.
**Reason 3: The redirect URL specified is not valid**
```
Message: Redirect url invalid
```
Ensure the redirect URL in your request is correct. It must match one of the redirect URLs specified when you created or updated the AppClient. To view the list of allowed redirect URLs, use the [GetAppClient](manage-appclients.md#get_appclient_details) API operation.
## `Token` errors
### TokenException
You might receive the following exception for a few reasons.
```
TokenException
HTTP Status Code: 400
```
**Reason 1: When an email that is not valid is specified**
```
Message: Invalid Email used
```
Ensure the email address you’re using matches the one listed for the `starterUserEmails` attribute when you created the AppClient. If the emails don’t match, change to the matching email address and try again. To view the email used, use the [GetAppClient](manage-appclients.md#get_appclient_details) API operation.
**Reason 2: For grant\$1type as refresh\$1token when the token is not specified.**
```
Message: refresh_token must be non-null for Refresh Token Grant-type
```
The refresh token specified in the request is null or empty. Specify an active `refresh_token` received in [Token](getting-started-appdeveloper-productivity.md#authorize_data_access) API call response.
### ThrottlingException
You might receive the following exception if the API is being called at rate which is more than the allowed quota.
```
ThrottlingException
HTTP Status Code: 429
```
## `ListActionableInsights`, `ListMeetingInsights`, and `PutFeedback` errors
### ValidationException
You might receive the following exception if any of the API parameters don't satisfy the constraint defined on the API specifications.
```
ValidationException
HTTP Status Code: 400
```
### ThrottlingException
You might receive the following exception if the API is being called at rate which is more than the allowed quota.
```
ThrottlingException
HTTP Status Code: 429
```
# Get started with AppFabric for productivity (preview) for end users
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
This section is intended for end users of SaaS applications who want to enable AWS AppFabric for productivity (preview) to improve their task management and workflow efficiency. Follow these steps to connect your applications and authorize AppFabric to surface cross-app insights and help you complete actions (such as send an email or schedule a meeting) from your preferred applications. You can connect applications such as Asana, Atlassian Jira Suite, Google Workspace, Microsoft 365, Miro, Slack, Smartsheet, and more. After you authorize AppFabric to access your content, AppFabric brings cross-app insights and actions directly within your preferred apps — helping you work more efficiently and stay within your current workflows.
AppFabric for productivity uses generative AI that is powered by Amazon Bedrock. AppFabric will generate insights and actions only after receiving your explicit permission. You authorize each individual application to remain in full control of which content is used. AppFabric will not use your data to train or improve the underlying large language models used to generate insights. For more information, please see [Amazon Bedrock FAQs](https://aws.amazon.com/bedrock/faqs/).
**Topics**
+ [Prerequisites](#getting-started-prerequisites)
+ [Step 1. Sign in to AppFabric](#sign-in-appfabric)
+ [Step 2. Provide consent for the app to display insights](#provide-consent)
+ [Step 3. Connect your applications to generate insights and actions](#connect-apps)
+ [Step 4. Start seeing insights and execute cross-app actions in your application](#insights_in_app)
+ [Manage access to AppFabric for productivity (preview) features for IT and security administrators](productivity-end-users-managing-access.md)
+ [Troubleshoot end user errors in AppFabric for productivity](productivity-end-users-errors.md)
## Prerequisites
Before beginning, ensure you have the following:
+ Credentials to sign in to AppFabric: To start using AppFabric for productivity, you will need federated sign-in credentials (user name and password) for one of the following providers: Asana, Google Workspace, Microsoft 365, or Slack. Signing in to AppFabric helps us identify you as a user across each application you enable AppFabric for productivity. After signing in, you can connect your applications to start generating insights.
+ Credentials to connect your applications: Cross-app insights and actions are only generated based on applications that you authorize. You will need sign-in credentials (user name and password) for each of the applications you want to authorize. Supported applications include Asana, Atlassian Jira Suite, Google Workspace, Microsoft 365, Miro, Slack, and Smartsheet.
## Step 1. Sign in to AppFabric
Connect applications to AppFabric to bring your content and insights directly within your preferred applications.
1. Every application will use AppFabric for productivity in different ways to bring you richer app experiences. Due to this, every application will have a different entry point to reach the AppFabric for productivity home page below. The home page sets context about the process to enable AppFabric and first prompts you to sign in. Every application you want to enable AppFabric in will reach this screen.
![\[Sign-in prompt for AWS AppFabric, highlighting AI-powered productivity features.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-01.png)
1. Sign in with your credentials from one of these providers: Asana, Google Workspace, Microsoft 365, or Slack. For the best experience, we recommend signing in using the same provider for each application you enable AppFabric in. For instance, if you choose Google Workspace credentials in App1, we recommend choosing Google Workspace in App2, as well as every other time you need to sign back in. If you sign in with a different provider, you’ll need to restart the process of connecting applications.
![\[AWS AppFabric sign-in page with options for Slack, Microsoft, Google, and Asana.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-02.png)
1. If prompted, enter your sign-in credentials and accept signing into AppFabric from this provider.
![\[Slack sign-in page with options for Google, Apple, or email authentication.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-03.png)
![\[Sign-in interface for AWS AppFabric with Slack, showing account selection and connection details.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-04.png)
## Step 2. Provide consent for the app to display insights
After signing in, AppFabric will display a consent page asking if you allow AppFabric to display cross-app insights and actions inside the application you’re enabling AppFabric for productivity in. For example, do you allow AppFabric to take your Google Workspace emails and calendar events and display them in Asana. You only need to complete this consent step one time per application that you enable AppFabric in.
![\[Dialog box requesting permission to display insights and artifacts within an application.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-05.png)
## Step 3. Connect your applications to generate insights and actions
After you complete the consent page, you're taken to the **Connect applications** page where you can connect, disconnect, or reconnect individual applications that are ultimately used to generate your cross-app insights and actions. In most cases, after you’ve signed in and provided consent, you'll continue to use this page to manage your connected applications.
To connect an application, choose the **Connect** button next to any application that you use.
![\[List of applications to connect, including Smartsheet, Slack, and Google Workspace, all showing as not connected.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-06.png)
You will need to provide your sign-in credentials for the application, and allow AppFabric permission to access your data to generate insights and complete actions.
![\[Dialog box requesting permission for AWS AppFabric to access Slack workspace data.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-07.png)
After you successfully connect an application, the Status for that application will change from “Not Connected” to “Connected”. Reminder: you need to complete this authorization step for every application you want to be used for generating insights and actions.
After you connect an application, it's not connected forever. You'll need to periodically re-connect applications. We do this to ensure we still have your permission to generate insights.
The possible application statuses are:
+ Connected - AppFabric is authorized and is generating insights using your data from this application.
+ Not Connected - AppFabric isn't generating insights using data from this application. You can connect to begin generating insights.
+ Authorization failed. Please reconnect. - There may be an authorization failure with a specific application. If you see this error, try reconnecting your application using the **Connect** button.
![\[Application connection status interface showing connected and unconnected apps.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-08.png)
The set up is complete and you can return to your application. It can take at least a few hours to start seeing insights inside your applications.
As needed, you can navigate back to this page to manage your connected applications. If you choose to **Disconnect** an application, AppFabric will stop using data from that application or gathering new data to generate new insights. Data from disconnected applications will be automatically be deleted within 7 days if you choose to not reconnect the application in that time.
## Step 4. Start seeing insights and execute cross-app actions in your application
After you connect your applications with AppFabric, you'll have access to valuable insights and the ability to perform cross-app actions directly from your preferred application. Note: this functionality is not guaranteed in each app and entirely dependent on which AppFabric for productivity features the application developer has chosen to enable.
**Cross-app insights**
AppFabric for productivity offers two types of insights:
+ Actionable insights: AppFabric analyzes information from your emails, calendar events, tasks, and messages across your connected apps and generates key insights that may be important for you to prioritize. Additionally, AppFabric may generate recommended actions (such as send email, schedule meeting, and create task) that you can edit and execute while staying in your preferred application. For example, you may receive an insight saying there’s a customer escalation to deal with and a suggested next action to schedule a meeting with your customer.
+ Meeting preparation insights: This feature helps you best prepare for upcoming meetings. AppFabric will analyze your upcoming meetings and generate a concise summary about the meeting purpose. Additionally, it will surface relevant artifacts (such as emails, messages, and tasks) from your connected applications that will be useful to help you efficiently prepare for the meeting without switching between apps to find content.
**Cross-app actions**
For certain insights, AppFabric may also generate recommended actions such as sending an email, scheduling a meeting, or creating a task. When generating actions, AppFabric may pre-populate certain fields based on the content and context of your connected applications. For example, AppFabric may generate a suggested email response or task name based on the insight. When you click on a suggested action, you will be taken to an AppFabric owned user interface where you can edit the pre-populated content before executing the action. AppFabric will not execute actions without user review and input first as generative AI and the underlying large language models (LLM) may hallucinate from time to time.
**Note**
You have the responsibility to validate and confirm the AppFabric LLM outputs. AppFabric does not guarantee the accuracy or quality of its LLM outputs. For more information, see [AWS Responsible AI Policy](https://aws.amazon.com/machine-learning/responsible-ai/policy/).
### Create emails (Google Workspace, Microsoft 365)
AppFabric allows you to edit and send an email from within your preferred application. We support basic email fields including the From, To, Cc/Bcc, Email Subject Line, and Email Body Message. AppFabric may generate content in these fields to help you reduce the time to complete the task. After you're done editing the email, choose **Send** to send the email.
The following fields are required to send an email:
+ At least one of recipient emails (To, CC and BCC) is required, and must be valid email addresses.
+ Subject line and Message fields.
![\[Email form with From, To, CC, BCC, Subject line, and Message fields for sending.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-12.png)
After the email is sent, you'll see a confirmation that the email has been sent. Additionally, you'll see a link to view the email in the designated application. You can use this link to quickly navigate to the application and verify the email has been sent.
![\[Email sent confirmation with recipient details and message preview.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-13.png)
### Create calendar events (Google Workspace, Microsoft 365)
AppFabric allows you to edit and create a calendar event from within your preferred application. We support basic calendar event fields including the Event Title, Location, Start/End Time and Date, Invitee list, and Event details. AppFabric may generate content in these fields to help you reduce the time to complete the task. After you're done editing the calendar event, choose **Create** to create the event.
The following fields are required to create a calendar event:
+ Title, Starts, Ends and Description fields.
+ Starts time and date must not be earlier than Ends time and date.
+ Invite field is optional, but requires valid email addresses if provided.
![\[Calendar event creation form with title, time, location, invitees, and description fields.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-14.png)
After calendar event is sent, you'll see a confirmation that the event has been created. Additionally, you'll see a link to view the event in the designated application. You can use this link to quickly navigate to the application and verify the event was created.
![\[Calendar event creation confirmation with event details and option to view in Google Calendar.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-15.png)
### Create tasks (Asana)
AppFabric allows you to edit and create a task in Asana from within your preferred application. We support basic task fields such as Task Name, Task Owner, Due Date, and Task Description. AppFabric may generate content in these fields to help you reduce the time to create the task. After you're done editing the task, choose **Create** to create the task. Tasks are created in the applicable Asana workspace or project or task, as suggested by the LLM.
The following fields are required to create an Asana task:
+ Title and Description fields.
+ Assignee must be valid email address if modified.
![\[Create Task form with fields for title, assignee, due date, and description for a finance meeting task.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-16.png)
After the task is created, you'll see a confirmation that the task has been created in Asana. Additionally, you'll see a link to view the task in Asana. You can use this link to quickly navigate to the application to verify the task was created, or move it to the appropriate Asana workspace or project or task.
![\[Task creation confirmation with details and a link to view in Asana.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-17.png)
### Create tasks (Smartsheet)
AppFabric allows you to edit and create a task in Smartsheet from within your preferred application. We support basic task fields such as Task Name, Task Owner, Due Date, and Task Description. AppFabric may generate content in these fields to help you reduce the time to create the task. After you're done editing the task, choose **Create** to create the task. For Smartsheet tasks, AppFabric will create a new private Smartsheet sheet and populate any created tasks. This is done to help centralize AppFabric generated actions in a single place in a structured manner.
The following fields are required to create an Smartsheet task:
+ Title and Description fields.
+ Assignee must be valid email address if provided.
![\[Create Task form with fields for title, assignees, due date, and description for an AWS AppFabric Action.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-18.png)
After the task is created, you'll see a confirmation that the task has been created in Smartsheet. Additionally, you'll see a link to view the task in Smartsheet. You can use this link to quickly navigate to the application to view the task in the created Smartsheet sheet. All future Smartsheet tasks will be populated in this sheet. If the sheet is deleted, AppFabric will create a new one.
![\[AWS AppFabric Action interface showing a successfully created task with details.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-19.png)
# Manage access to AppFabric for productivity (preview) features for IT and security administrators
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
The AppFabric for productivity user portal is publicly accessible to all users of SaaS applications who have integrated with AppFabric for productivity (preview) features. If you're an IT Administrator who wants to manage access to these generative AI features within your organization, consider these options:
+ Restrict Identity Provider (IdP) Login: You can block login access through your Identity Provider to control user access to generative AI features.
+ Disable OAuth for Specific Applications: Implement downstream restrictions by disabling OAuth. This action prevents users from connecting applications that require OAuth authentication to the company's workspace.
# Troubleshoot end user errors in AppFabric for productivity
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
This section describes common errors and troubleshooting for AppFabric for productivity.
## Unverified application
Applications that use AppFabric for productivity to enrich their app experiences will go through a verification process prior to launching their features to end users. If you encounter an “unverified” banner when trying to sign in to AppFabric, this means that the application has not undergone AppFabric’s verification process which confirms the app developer’s identity and accuracy of the application’s registration information. All applications start as unverified and change to verified only when the verification process is complete.
Be cautious while using an unverified application. If you're unsure about the app developers, you may wait until the application attains verified status before proceeding.
![\[Warning message for an unverified application in AWS AppFabric, advising caution before authorization.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-20.png)
## Something went wrong. Please try it again or check with your Admin (`InternalServerException`)
You might get this message when the AppFabric user portal fails to list the applications or disconnects an application due to an unknown error, exception, or failure. Try again later.
![\[Connect applications interface showing connected and not connected apps with action buttons.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-23.png)
## The request was denied due to request throttling. Please try it again in some time (`ThrottlingException`)
You might get this message when the AppFabric user portal fails to list the applications or disconnects an application due to a throttling issue. Try again later.
![\[Connect applications interface showing connected and not connected apps with action buttons.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-22.png)
## You are not authorized to use AppFabric. Please log in to AppFabric again (`AccessDeniedException`)
You might get this message when the AppFabric user portal fails to list the applications or disconnects an application due to an access denied exception. Sign in to AppFabric again.
![\[Connect applications interface showing connected and unconnected apps with action buttons.\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/images/fabric-21.png)
# AppFabric for productivity APIs (preview)
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
This section provides the API operations, data types, and common errors for the AWS AppFabric productivity features.
**Note**
For all other AppFabric APIs, see the [AWS AppFabric API Reference](https://docs.aws.amazon.com/appfabric/latest/api/).
**Topics**
+ [API actions for AppFabric for productivity (preview)](productivity-actions.md)
+ [API data types for AppFabric for productivity (preview)](productivity-data-types.md)
+ [Common API errors for AppFabric for productivity (preview)](productivity-common-errors.md)
# API actions for AppFabric for productivity (preview)
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
The following actions are supported for the AppFabric for productivity features.
For all other AppFabric API actions, see the [AWS AppFabric API Actions](https://docs.aws.amazon.com/appfabric/latest/api/API_Operations.html).
**Topics**
+ [Authorize](API_Authorize.md)
+ [CreateAppClient](API_CreateAppClient.md)
+ [DeleteAppClient](API_DeleteAppClient.md)
+ [GetAppClient](API_GetAppClient.md)
+ [ListActionableInsights](API_ListActionableInsights.md)
+ [ListAppClients](API_ListAppClients.md)
+ [ListMeetingInsights](API_ListMeetingInsights.md)
+ [PutFeedback](API_PutFeedback.md)
+ [Token](API_Token.md)
+ [UpdateAppClient](API_UpdateAppClient.md)
# Authorize
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Authorizes an AppClient.
**Topics**
+ [Request body](#API_Authorize_request)
## Request body
The request accepts the following data in JSON format.
| Parameter | Description |
| --- | --- |
| **app\$1client\$1id** | The ID of the AppClient to authorize. |
| **redirect\$1uri** | The URI to redirect end users to after authorization. |
| **state** | A unique value to maintain the state between the request and callback. |
# CreateAppClient
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Creates an AppClient.
**Topics**
+ [Request body](#API_CreateAppClient_request)
+ [Response elements](#API_CreateAppClient_response)
## Request body
The request accepts the following data in JSON format.
| Parameter | Description |
| --- | --- |
| **appName** | The name of the app. Type: String Length Constraints: Minimum length of 1. Maximum length of 255. Required: Yes |
| **clientToken** | Specifies a unique, case-sensitive identifier that you provide to ensure the idempotency of the request. This lets you safely retry the request without accidentally performing the same operation a second time. Passing the same value to a later call to an operation requires that you also pass the same value for all other parameters. We recommend that you use a [UUID type of value](https://wikipedia.org/wiki/Universally_unique_identifier). If you don't provide this value, then AWS generates a random one for you. If you retry the operation with the same `ClientToken`, but with different parameters, the retry fails with an `IdempotentParameterMismatch` error. Type: String Pattern: `[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}` Required: No |
| **customerManagedKeyIdentifier** | The ARN of the customer managed key generated by AWS Key Management Service. The key is used to encrypt the data. If no key is specified, then an AWS managed key is used. A map of the key-value pairs of the tag or tags to assign to the resource. For more information about AWS owned keys and customer managed keys, see [Customer keys and AWS keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-mgmt) in the *AWS Key Management Service Developer Guide*. Type: String Length Constraints: Minimum length of 1. Maximum length of 1011. Pattern: `arn:.+$\|^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}` Required: No |
| **description** | A description for the app. Type: String Required: Yes |
| **iconUrl** | The URL to the icon or logo for the AppClient. Type: String Required: No |
| **redirectUrls** | The URI to redirect end users to after authorization. You can add up to 5 redirectUrls. For example, `https://localhost:8080`. Type: Array of strings Array Members: Minimum number of 1 item. Maximum number of 5 items. Length Constraints: Minimum length of 1. Maximum length of 2048. Pattern: `(http\|https):\/\/[-a-zA-Z0-9_:.\/]+` Required: Yes |
| **starterUserEmails** | Starter email addresses for users who are allowed access to receive insights until the AppClient is verified. Type: Array of strings Array Members: Fixed number of 1 item. Length Constraints: Minimum length of 0. Maximum length of 320. Pattern: `[a-zA-Z0-9.!#$%&’*+/=?^_`{\|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*` Required: Yes |
| **tags** | A map of the key-value pairs of the tag or tags to assign to the resource. Type: Array of Tag objects Array Members: Minimum number of 0 items. Maximum number of 50 items. Required: No |
## Response elements
If the action is successful, the service sends back an HTTP 201 response.
The following data is returned in JSON format by the service.
| Parameter | Description |
| --- | --- |
| **appClientSummary** | Contains a summary of the AppClient. Type: [AppClientSummary](API_AppClientSummary.md) object |
# DeleteAppClient
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Deletes an application client.
**Topics**
+ [Request body](#API_DeleteAppClient_request)
+ [Response elements](#API_DeleteAppClient_response)
## Request body
The request accepts the following data in JSON format.
| Parameter | Description |
| --- | --- |
| **appClientIdentifier** | The Amazon Resource Name (ARN) or Universal Unique Identifier (UUID) of the AppClient to use for the request. Length Constraints: Minimum length of 1. Maximum length of 1011. Pattern: `arn:.+$\|^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}` Required: Yes |
## Response elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.
# GetAppClient
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Returns information about an AppClient.
**Topics**
+ [Request body](#API_GetAppClient_request)
+ [Response elements](#API_GetAppClient_response)
## Request body
The request accepts the following data in JSON format.
| Parameter | Description |
| --- | --- |
| **appClientIdentifier** | The Amazon Resource Name (ARN) or Universal Unique Identifier (UUID) of the AppClient to use for the request. Length Constraints: Minimum length of 1. Maximum length of 1011. Pattern: `arn:.+$\|^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}` Required: Yes |
## Response elements
If the action is successful, the service sends back an HTTP 200 response.
The following data is returned in JSON format by the service.
| Parameter | Description |
| --- | --- |
| **appClient** | Contains information about an AppClient. Type: [AppClient](API_AppClient.md) object |
# ListActionableInsights
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Lists the most important actionable email messages, tasks, and other updates.
**Topics**
+ [Request body](#API_ListActionableInsights_request)
+ [Response elements](#API_ListActionableInsights_response)
## Request body
The request accepts the following data in JSON format.
| Parameter | Description |
| --- | --- |
| **nextToken** | If `nextToken` is returned, there are more results available. The value of `nextToken` is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an *HTTP 400 InvalidToken error*. |
## Response elements
If the action is successful, the service sends back an HTTP 201 response.
The following data is returned in JSON format by the service.
| Parameter | Description |
| --- | --- |
| **ActionableInsightsList** | Lists the actionable insights, including a title, description, actions, and created timestamp. For more information, see [ActionableInsights](API_ActionableInsights.md). |
| **nextToken** | If `nextToken` is returned, there are more results available. The value of `nextToken` is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an *HTTP 400 InvalidToken error*. Type: String |
# ListAppClients
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Returns a list of all AppClients.
**Topics**
+ [Request body](#API_ListAppClients_request)
+ [Response elements](#API_ListAppClients_response)
## Request body
The request accepts the following data in JSON format.
| Parameter | Description |
| --- | --- |
| **maxResults** | The maximum number of results that are returned per call. You can use `nextToken` to obtain further pages of results. This is only an upper limit. The actual number of results returned per call might be fewer than the specified maximum. Valid Range: Minimum value of 1. Maximum value of 100. |
| **nextToken** | If `nextToken` is returned, there are more results available. The value of `nextToken` is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an *HTTP 400 InvalidToken error*. |
## Response elements
If the action is successful, the service sends back an HTTP 200 response.
The following data is returned in JSON format by the service.
| Parameter | Description |
| --- | --- |
| **appClientList** | Contains a list of AppClient results. Type: Array of [AppClientSummary](API_AppClientSummary.md) objects |
| **nextToken** | If `nextToken` is returned, there are more results available. The value of `nextToken` is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an *HTTP 400 InvalidToken error*. Type: String |
# ListMeetingInsights
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Lists the most important actionable calendar events.
**Topics**
+ [Request body](#API_ListMeetingInsights_request)
+ [Response elements](#API_ListMeetingInsights_response)
## Request body
The request accepts the following data in JSON format.
| Parameter | Description |
| --- | --- |
| **nextToken** | If `nextToken` is returned, there are more results available. The value of `nextToken` is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an *HTTP 400 InvalidToken error*. |
## Response elements
If the action is successful, the service sends back an HTTP 201 response.
The following data is returned in JSON format by the service.
| Parameter | Description |
| --- | --- |
| **MeetingInsightList** | Lists the actionable meeting insights. For more information, see [MeetingInsights](API_MeetingInsights.md). |
| **nextToken** | If `nextToken` is returned, there are more results available. The value of `nextToken` is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged. Each pagination token expires after 24 hours. Using an expired pagination token will return an *HTTP 400 InvalidToken error*. Type: String |
# PutFeedback
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Allows users to submit feedback for a given insight or action.
**Topics**
+ [Request body](#API_PutFeedback_request)
+ [Response elements](#API_PutFeedback_response)
## Request body
The request accepts the following data in JSON format.
| Parameter | Description |
| --- | --- |
| **id** | The ID of the object for which feedback is being submitted. This can be either the InsightId or the ActionId. |
| **feedbackFor** | The insight type for which the feedback is being submitted. Possible values: `ACTIONABLE_INSIGHT \| MEETING_INSIGHT \| ACTION` |
| **feedbackRating** | Feedback Rating from `1` to `5`. Higher rating the better. |
## Response elements
If the action is successful, the service sends back an HTTP 201 response with an empty HTTP body.
# Token
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Contains information that allows AppClients to exchange an authorization code for an access token.
**Topics**
+ [Request body](#API_Token_request)
+ [Response elements](#API_Token_response)
## Request body
The request accepts the following data in JSON format.
| Parameter | Description |
| --- | --- |
| **code** | The authorization code received from the authorization endpoint. Type: String Length Constraints: Minimum length of 1. Maximum length of 2048. Required: No |
| **grant\$1type** | The grant type for the token. Must be either `authorization_code` or `refresh_token`. Type: String Required: Yes |
| **app\$1client\$1id** | The ID of the AppClient. Type: String Pattern: `[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}` Required: Yes |
| **redirect\$1uri** | The redirect URI passed to the authorization endpoint. Type: String Required: No |
| **refresh\$1token** | The refresh token received from the initial token request. Type: String Length Constraints: Minimum length of 1. Maximum length of 4096. Required: No |
## Response elements
If the action is successful, the service sends back an HTTP 200 response.
The following data is returned in JSON format by the service.
| Parameter | Description |
| --- | --- |
| **appfabric\$1user\$1id** | The ID of the user for the token. This is returned only for requests that use the `authorization_code` grant type. Type: String |
| **expires\$1in** | The number of seconds until the token expires. Type: Long |
| **refresh\$1token** | The refresh token to use for a subsequent request. Type: String Length Constraints: Minimum length of 1. Maximum length of 2048. |
| **token** | The access token. Type: String Length Constraints: Minimum length of 1. Maximum length of 2048. |
| **token\$1type** | The token type. Type: String |
# UpdateAppClient
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Updates an AppClient.
**Topics**
+ [Request body](#API_UpdateAppClient_request)
+ [Response elements](#API_UpdateAppClient_response)
## Request body
The request accepts the following data in JSON format.
| Parameter | Description |
| --- | --- |
| **appClientIdentifier** | The Amazon Resource Name (ARN) or Universal Unique Identifier (UUID) of the AppClient to use for the request. Length Constraints: Minimum length of 1. Maximum length of 1011. Pattern: `arn:.+$\|^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}` Required: Yes |
| **redirectUrls** | The URI to redirect end users to after authorization. You can add up to 5 redirectUrls. For example, `https://localhost:8080`. Type: Array of strings Array Members: Minimum number of 1 item. Maximum number of 5 items. Length Constraints: Minimum length of 1. Maximum length of 2048. Pattern: `(http\|https):\/\/[-a-zA-Z0-9_:.\/]+` |
## Response elements
If the action is successful, the service sends back an HTTP 200 response.
The following data is returned in JSON format by the service.
| Parameter | Description |
| --- | --- |
| **appClient** | Contains information about an AppClient. Type: [AppClient](API_AppClient.md) object |
# API data types for AppFabric for productivity (preview)
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
The AppFabric API contains several data types that various actions use. This section describes the data types for the AppFabric for productivity features in detail.
For all other AppFabric API data types, see the [AWS AppFabric API Data Types](https://docs.aws.amazon.com/appfabric/latest/api/API_Types.html).
**Important**
The order of each element in a data type structure is not guaranteed. Applications should not assume a particular order.
**Topics**
+ [ActionableInsights](API_ActionableInsights.md)
+ [AppClient](API_AppClient.md)
+ [AppClientSummary](API_AppClientSummary.md)
+ [MeetingInsights](API_MeetingInsights.md)
+ [VerificationDetails](API_VerificationDetails.md)
# ActionableInsights
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Contains a summary of important and suitable actions for a user based on emails, calendar invites, messages, and tasks from their app portfolio. Users can see proactive insights from across their applications to help them best orient their day. These insights provide justification on why a user should care about the insight summary along with references, such as embedded links, to individual apps and artifacts that generated the insight.
| Parameter | Description |
| --- | --- |
| **insightId** | The unique id for the generated insight. |
| **insightContent** | This returns a summary of the insight and embedded links to artifacts used to generate the insight. This would be an HTML content containing embedded links (`` tags). |
| **insightTitle** | The title of the generated insight. |
| **createdAt** | When the insight was generated. |
| **actions** | A list of actions recommend for the generated insight. The action object contains the following parameters: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/API_ActionableInsights.html) |
# AppClient
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Contains information about an AppClient.
**Topics**
| Parameter | Description |
| --- | --- |
| **appName** | The name of the application. Type: String Required: Yes |
| **arn** | The Amazon Resource Name (ARN) of the AppClient. Type: String Length Constraints: Minimum length of 1. Maximum length of 1011. Pattern: `arn:.+` Required: Yes |
| **description** | A description for the application. Type: String Required: Yes |
| **iconUrl** | The URL to the icon or logo for the AppClient. Type: String Required: No |
| **redirectUrls** | The allowed redirect URLs for the AppClient. Type: Array of strings Array Members: Minimum number of 1 item. Maximum number of 5 items. Length Constraints: Minimum length of 1. Maximum length of 2048. Pattern: `(http\|https):\/\/[-a-zA-Z0-9_:.\/]+` Required: Yes |
| **starterUserEmails** | Starter email addresses for users who are allowed access to receive insights until the AppClient is verified. Type: Array of strings Array Members: Fixed number of 1 item. Length Constraints: Minimum length of 0. Maximum length of 320. Pattern: `[a-zA-Z0-9.!#$%&’*+/=?^_`{\|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*` Required: Yes |
| **verificationDetails** | Contains the status and reason for the AppClient verification. Type: [VerificationDetails](API_VerificationDetails.md) object Required: Yes |
| **customerManagedKeyArn** | The Amazon Resource Name (ARN) of the customer managed key generated by AWS Key Management Service for the AppClient. Type: String Length Constraints: Minimum length of 1. Maximum length of 1011. Pattern: `arn:.+` Required: No |
| **appClientId** | The ID of the AppClient. Meant to be used in o-auth flows for the app-client. Type: String Pattern: `[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}` Required: No |
# AppClientSummary
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Contains information about an AppClient.
**Topics**
| Parameter | Description |
| --- | --- |
| **arn** | The Amazon Resource Name (ARN) of the AppClient. Type: String Length Constraints: Minimum length of 1. Maximum length of 1011. Pattern: `arn:.+` Required: Yes |
| **verificationStatus** | The AppClient verification status. Type: String Valid Values: `pending_verification \| verified \| rejected` Required: Yes |
| **appClientId** | The ID of the AppClient. Meant to be used in o-auth flows for the app-client. Type: String Pattern: `[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}` Required: No |
# MeetingInsights
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Contains a summary of the top 3 meetings along with meeting purpose, related cross-app artifacts, and activities from tasks, emails, messages, and calendar events.
| Parameter | Description |
| --- | --- |
| **insightId** | The unique id for the generated insight. |
| **insightContent** | The description of the insight highlighting the details in a string format. As in, why is this insight important. |
| **insightTitle** | The title of the generated insight. |
| **createdAt** | When the insight was generated. |
| **calendarEvent** | The important calendar event or meeting that the user should focus on. Calendar Event object: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/API_MeetingInsights.html) |
| **resources** | The list containing the other resources related to the generate the insight. Resource object: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/appfabric/latest/adminguide/API_MeetingInsights.html) |
| **nextToken** | The pagination token to fetch the next set of insights. It’s an optional field which if returned null means there are no more insights to load. |
# VerificationDetails
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
Contains the status and reason for the AppClient verification.
**Topics**
| Parameter | Description |
| --- | --- |
| **verificationStatus** | The AppClient verification status. Type: String Valid Values: `pending_verification \| verified \| rejected` Required: Yes |
| **statusReason** | The AppClient verification status reason. Type: String Length Constraints: Minimum length of 1. Maximum length of 1024. Required: No |
# Common API errors for AppFabric for productivity (preview)
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
This section lists the errors common to the API actions for the AWS AppFabric productivity features.
For all other AppFabric common API errors, see [Troubleshoot AppClients in AppFabric for productivity](ahead-app-dev-errors.md) and [AWS AppFabric API common errors](https://docs.aws.amazon.com/appfabric/latest/api/CommonErrors.html) in the *AWS AppFabric API Reference*.
| Exception name | Description |
| --- | --- |
| **TokenException** | The token request is not valid. HTTP Status Code: 400 |
# Data processing in AppFabric
| |
| --- |
| The AWS AppFabric for productivity feature is in preview and is subject to change. |
AppFabric takes steps to store user content individually, in an Amazon S3 bucket managed by AppFabric, and separately; which helps ensure that we generate user-specific insights. We use reasonable safeguards to protect your content, which can include encryption at-rest and in-transit. We've configured our systems to delete customer content automatically within 30 days from ingestion. AppFabric does not generate insights using data artifacts to which a user no longer has access. For example, when a user disconnects a data source (an app), AppFabric stops collecting data from that app and does not use any lingering artifacts from the disconnected apps to generate insights. AppFabric’s systems are configured to delete such data within 30 days.
AppFabric does not use user content to train or improve the underlying large language models used to generate insights. For more information about AppFabric's generative AI feature, see [Amazon Bedrock FAQs](https://aws.amazon.com/bedrock/faqs/).
## Encryption at rest
AWS AppFabric supports encryption at rest, a server-side encryption feature in which AppFabric transparently encrypts all data related to users when it is persisted to disk, and decrypts them when you access the data.
## Encryption in transit
AppFabric secures all content in transit using TLS 1.2 and signs API requests for AWS services with AWS Signature Version 4.